eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.OKC_RDS_PVT dependencies on OKC_API

Line 25: g_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

21: G_SQLCODE_TOKEN CONSTANT VARCHAR2(200) := 'SQLcode';
22: G_INVALID_RULE_SOURCE CONSTANT VARCHAR2(200) := 'OKC_INVALID_RULE_SOURCE';
23: G_VIEW CONSTANT VARCHAR2(200) := 'OKC_RULE_DEF_SOURCES_V';
24: G_EXCEPTION_HALT_VALIDATION exception;
25: g_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
26: g_row_id ROWID;
27:
28: -- Start of comments
29: --

Line 49: x_return_status := OKC_API.G_RET_STS_SUCCESS;

45: WHERE rgrv.rgd_code = p_rdsv_rec.rgr_rgd_code
46: AND rgrv.rdf_code = p_rdsv_rec.rgr_rdf_code;
47: BEGIN
48: -- initialize return status
49: x_return_status := OKC_API.G_RET_STS_SUCCESS;
50:
51: -- data is required
52: IF (p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
53: p_rdsv_rec.rgr_rdf_code IS NULL) THEN

Line 52: IF (p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR

48: -- initialize return status
49: x_return_status := OKC_API.G_RET_STS_SUCCESS;
50:
51: -- data is required
52: IF (p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
53: p_rdsv_rec.rgr_rdf_code IS NULL) THEN
54: OKC_API.set_message(
55: p_app_name => G_APP_NAME,
56: p_msg_name => G_REQUIRED_VALUE,

Line 54: OKC_API.set_message(

50:
51: -- data is required
52: IF (p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
53: p_rdsv_rec.rgr_rdf_code IS NULL) THEN
54: OKC_API.set_message(
55: p_app_name => G_APP_NAME,
56: p_msg_name => G_REQUIRED_VALUE,
57: p_token1 => G_COL_NAME_TOKEN,
58: p_token1_value => 'rgr_rgd_code');

Line 61: x_return_status := OKC_API.G_RET_STS_ERROR;

57: p_token1 => G_COL_NAME_TOKEN,
58: p_token1_value => 'rgr_rgd_code');
59:
60: -- notify caller of an error
61: x_return_status := OKC_API.G_RET_STS_ERROR;
62:
63: -- halt validation
64: RAISE G_EXCEPTION_HALT_VALIDATION;
65: END IF;

Line 68: IF (p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR

64: RAISE G_EXCEPTION_HALT_VALIDATION;
65: END IF;
66:
67: -- data is required
68: IF (p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR
69: p_rdsv_rec.rgr_rdf_code IS NULL) THEN
70: OKC_API.set_message(
71: p_app_name => G_APP_NAME,
72: p_msg_name => G_REQUIRED_VALUE,

Line 70: OKC_API.set_message(

66:
67: -- data is required
68: IF (p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR
69: p_rdsv_rec.rgr_rdf_code IS NULL) THEN
70: OKC_API.set_message(
71: p_app_name => G_APP_NAME,
72: p_msg_name => G_REQUIRED_VALUE,
73: p_token1 => G_COL_NAME_TOKEN,
74: p_token1_value => 'rgr_rdf_code');

Line 77: x_return_status := OKC_API.G_RET_STS_ERROR;

73: p_token1 => G_COL_NAME_TOKEN,
74: p_token1_value => 'rgr_rdf_code');
75:
76: -- notify caller of an error
77: x_return_status := OKC_API.G_RET_STS_ERROR;
78:
79: -- halt validation
80: RAISE G_EXCEPTION_HALT_VALIDATION;
81: END IF;

Line 91: OKC_API.set_message(

87:
88: -- if l_dummy_var still set to default, data was not found
89: IF (l_dummy_var = '?') THEN
90: --set error message in message stack
91: OKC_API.set_message(
92: p_app_name => G_APP_NAME,
93: p_msg_name => G_INVALID_VALUE,
94: p_token1 => G_COL_NAME_TOKEN,
95: p_token1_value => 'rgr_rgd_code/rgr_rdf_code');

Line 98: x_return_status := OKC_API.G_RET_STS_ERROR;

94: p_token1 => G_COL_NAME_TOKEN,
95: p_token1_value => 'rgr_rgd_code/rgr_rdf_code');
96:
97: -- notify caller of an error
98: x_return_status := OKC_API.G_RET_STS_ERROR;
99: END IF;
100: EXCEPTION
101: WHEN G_EXCEPTION_HALT_VALIDATION THEN
102: -- no processing necessary; validation can continue with next column

Line 106: OKC_API.SET_MESSAGE(

102: -- no processing necessary; validation can continue with next column
103: NULL;
104: WHEN OTHERS THEN
105: -- store SQL error message on message stack
106: OKC_API.SET_MESSAGE(
107: p_app_name => g_app_name,
108: p_msg_name => g_unexpected_error,
109: p_token1 => g_sqlcode_token,
110: p_token1_value => sqlcode,

Line 114: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

110: p_token1_value => sqlcode,
111: p_token2 => g_sqlerrm_token,
112: p_token2_value => sqlerrm);
113: -- notify caller of an error as UNEXPETED error
114: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
115: -- verify that cursor was closed
116: IF l_rgdv_csr%ISOPEN THEN
117: CLOSE l_rgdv_csr;
118: END IF;

Line 136: x_return_status := OKC_API.G_RET_STS_SUCCESS;

132: p_rdsv_rec IN rdsv_rec_type
133: ) IS
134: BEGIN
135: -- initialize return status
136: x_return_status := OKC_API.G_RET_STS_SUCCESS;
137:
138: -- data is required
139: IF (p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
140: p_rdsv_rec.buy_or_sell IS NULL) THEN

Line 139: IF (p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR

135: -- initialize return status
136: x_return_status := OKC_API.G_RET_STS_SUCCESS;
137:
138: -- data is required
139: IF (p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
140: p_rdsv_rec.buy_or_sell IS NULL) THEN
141: OKC_API.set_message(
142: p_app_name => G_APP_NAME,
143: p_msg_name => G_REQUIRED_VALUE,

Line 141: OKC_API.set_message(

137:
138: -- data is required
139: IF (p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
140: p_rdsv_rec.buy_or_sell IS NULL) THEN
141: OKC_API.set_message(
142: p_app_name => G_APP_NAME,
143: p_msg_name => G_REQUIRED_VALUE,
144: p_token1 => G_COL_NAME_TOKEN,
145: p_token1_value => 'buy_or_sell');

Line 148: x_return_status := OKC_API.G_RET_STS_ERROR;

144: p_token1 => G_COL_NAME_TOKEN,
145: p_token1_value => 'buy_or_sell');
146:
147: -- notify caller of an error
148: x_return_status := OKC_API.G_RET_STS_ERROR;
149:
150: -- halt validation
151: RAISE G_EXCEPTION_HALT_VALIDATION;
152: END IF;

Line 156: OKC_API.set_message(

152: END IF;
153:
154: -- check allowed values
155: IF (UPPER(p_rdsv_rec.buy_or_sell) NOT IN ('B','S')) THEN
156: OKC_API.set_message(
157: p_app_name => G_APP_NAME,
158: p_msg_name => G_INVALID_VALUE,
159: p_token1 => G_COL_NAME_TOKEN,
160: p_token1_value => 'buy_or_sell');

Line 162: x_return_status := OKC_API.G_RET_STS_ERROR;

158: p_msg_name => G_INVALID_VALUE,
159: p_token1 => G_COL_NAME_TOKEN,
160: p_token1_value => 'buy_or_sell');
161: -- notify caller of an error
162: x_return_status := OKC_API.G_RET_STS_ERROR;
163: END IF;
164: EXCEPTION
165: WHEN G_EXCEPTION_HALT_VALIDATION THEN
166: -- no processing necessary; validation can continue with next column

Line 170: OKC_API.SET_MESSAGE(

166: -- no processing necessary; validation can continue with next column
167: NULL;
168: WHEN OTHERS THEN
169: -- store SQL error message on message stack
170: OKC_API.SET_MESSAGE(
171: p_app_name => G_APP_NAME,
172: p_msg_name => G_UNEXPECTED_ERROR,
173: p_token1 => G_SQLCODE_TOKEN,
174: p_token1_value => SQLCODE,

Line 178: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

174: p_token1_value => SQLCODE,
175: p_token2 => G_SQLERRM_TOKEN,
176: p_token2_value => SQLERRM);
177: -- notify caller of an error as UNEXPETED error
178: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
179: -- verify that cursor was closed
180: END validate_buy_or_sell;
181: --
182: --

Line 206: x_return_status := OKC_API.G_RET_STS_SUCCESS;

202: AND rgdv.lookup_type = 'OKC_SEED_ACCESS_LEVEL_SU';
203:
204: BEGIN
205: -- initialize return status
206: x_return_status := OKC_API.G_RET_STS_SUCCESS;
207:
208: -- check for data
209: IF (p_rdsv_rec.access_level <> OKC_API.G_MISS_CHAR OR
210: p_rdsv_rec.access_level IS NOT NULL) THEN

Line 209: IF (p_rdsv_rec.access_level <> OKC_API.G_MISS_CHAR OR

205: -- initialize return status
206: x_return_status := OKC_API.G_RET_STS_SUCCESS;
207:
208: -- check for data
209: IF (p_rdsv_rec.access_level <> OKC_API.G_MISS_CHAR OR
210: p_rdsv_rec.access_level IS NOT NULL) THEN
211:
212: -- enforce foreign key
213: OPEN l_rgdv_csr;

Line 220: OKC_API.set_message(

216:
217: -- if l_dummy_var still set to default, data was not found
218: IF (l_dummy_var = '?') THEN
219: --set error message in message stack
220: OKC_API.set_message(
221: p_app_name => G_APP_NAME,
222: p_msg_name => G_INVALID_VALUE,
223: p_token1 => G_COL_NAME_TOKEN,
224: p_token1_value => 'access_level');

Line 227: x_return_status := OKC_API.G_RET_STS_ERROR;

223: p_token1 => G_COL_NAME_TOKEN,
224: p_token1_value => 'access_level');
225:
226: -- notify caller of an error
227: x_return_status := OKC_API.G_RET_STS_ERROR;
228: END IF;
229: END IF;
230: EXCEPTION
231: WHEN G_EXCEPTION_HALT_VALIDATION THEN

Line 236: OKC_API.SET_MESSAGE(

232: -- no processing necessary; validation can continue with next column
233: NULL;
234: WHEN OTHERS THEN
235: -- store SQL error message on message stack
236: OKC_API.SET_MESSAGE(
237: p_app_name => G_APP_NAME,
238: p_msg_name => G_UNEXPECTED_ERROR,
239: p_token1 => G_SQLCODE_TOKEN,
240: p_token1_value => SQLCODE,

Line 244: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

240: p_token1_value => SQLCODE,
241: p_token2 => G_SQLERRM_TOKEN,
242: p_token2_value => SQLERRM);
243: -- notify caller of an error as UNEXPETED error
244: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
245: -- verify that cursor was closed
246: END validate_access_level;
247: --
248:

Line 262: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

258: PROCEDURE validate_start_date(
259: x_return_status OUT NOCOPY VARCHAR2,
260: p_rdsv_rec IN rdsv_rec_type
261: ) IS
262: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
263:
264: BEGIN
265: -- initialize return status
266: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 266: x_return_status := OKC_API.G_RET_STS_SUCCESS;

262: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
263:
264: BEGIN
265: -- initialize return status
266: x_return_status := OKC_API.G_RET_STS_SUCCESS;
267:
268: -- data is required
269: IF (p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
270: p_rdsv_rec.start_date IS NULL) THEN

Line 269: IF (p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR

265: -- initialize return status
266: x_return_status := OKC_API.G_RET_STS_SUCCESS;
267:
268: -- data is required
269: IF (p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
270: p_rdsv_rec.start_date IS NULL) THEN
271: OKC_API.set_message(
272: p_app_name => G_APP_NAME,
273: p_msg_name => G_REQUIRED_VALUE,

Line 271: OKC_API.set_message(

267:
268: -- data is required
269: IF (p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
270: p_rdsv_rec.start_date IS NULL) THEN
271: OKC_API.set_message(
272: p_app_name => G_APP_NAME,
273: p_msg_name => G_REQUIRED_VALUE,
274: p_token1 => G_COL_NAME_TOKEN,
275: p_token1_value => 'start_date');

Line 278: x_return_status := OKC_API.G_RET_STS_ERROR;

274: p_token1 => G_COL_NAME_TOKEN,
275: p_token1_value => 'start_date');
276:
277: -- notify caller of an error
278: x_return_status := OKC_API.G_RET_STS_ERROR;
279:
280: -- halt validation
281: RAISE G_EXCEPTION_HALT_VALIDATION;
282: END IF;

Line 287: OKC_API.SET_MESSAGE(

283:
284: EXCEPTION
285: WHEN OTHERS THEN
286: -- store SQL error message on message stack
287: OKC_API.SET_MESSAGE(
288: p_app_name => G_APP_NAME,
289: p_msg_name => G_UNEXPECTED_ERROR,
290: p_token1 => G_SQLCODE_TOKEN,
291: p_token1_value => SQLCODE,

Line 295: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

291: p_token1_value => SQLCODE,
292: p_token2 => G_SQLERRM_TOKEN,
293: p_token2_value => SQLERRM);
294: -- notify caller of an error as UNEXPETED error
295: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
296: END validate_start_date;
297: --
298: -- Start of comments
299: --

Line 311: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

307: PROCEDURE validate_end_date(
308: x_return_status OUT NOCOPY VARCHAR2,
309: p_rdsv_rec IN rdsv_rec_type
310: ) IS
311: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
312:
313: BEGIN
314: -- initialize return status
315: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 315: x_return_status := OKC_API.G_RET_STS_SUCCESS;

311: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
312:
313: BEGIN
314: -- initialize return status
315: x_return_status := OKC_API.G_RET_STS_SUCCESS;
316:
317: -- check for data before processing
318: IF (p_rdsv_rec.end_date <> OKC_API.G_MISS_DATE OR
319: p_rdsv_rec.end_date IS NOT NULL) THEN

Line 318: IF (p_rdsv_rec.end_date <> OKC_API.G_MISS_DATE OR

314: -- initialize return status
315: x_return_status := OKC_API.G_RET_STS_SUCCESS;
316:
317: -- check for data before processing
318: IF (p_rdsv_rec.end_date <> OKC_API.G_MISS_DATE OR
319: p_rdsv_rec.end_date IS NOT NULL) THEN
320: IF (p_rdsv_rec.end_date < p_rdsv_rec.start_date) THEN
321: OKC_API.set_message(
322: p_app_name => G_APP_NAME,

Line 321: OKC_API.set_message(

317: -- check for data before processing
318: IF (p_rdsv_rec.end_date <> OKC_API.G_MISS_DATE OR
319: p_rdsv_rec.end_date IS NOT NULL) THEN
320: IF (p_rdsv_rec.end_date < p_rdsv_rec.start_date) THEN
321: OKC_API.set_message(
322: p_app_name => G_APP_NAME,
323: p_msg_name => G_INVALID_END_DATE);
324:
325: -- notify caller of an error

Line 326: x_return_status := OKC_API.G_RET_STS_ERROR;

322: p_app_name => G_APP_NAME,
323: p_msg_name => G_INVALID_END_DATE);
324:
325: -- notify caller of an error
326: x_return_status := OKC_API.G_RET_STS_ERROR;
327:
328: END IF;
329: END IF;
330:

Line 334: OKC_API.SET_MESSAGE(

330:
331: EXCEPTION
332: WHEN OTHERS THEN
333: -- store SQL error message on message stack
334: OKC_API.SET_MESSAGE(
335: p_app_name => G_APP_NAME,
336: p_msg_name => G_UNEXPECTED_ERROR,
337: p_token1 => G_SQLCODE_TOKEN,
338: p_token1_value => SQLCODE,

Line 342: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

338: p_token1_value => SQLCODE,
339: p_token2 => G_SQLERRM_TOKEN,
340: p_token2_value => SQLERRM);
341: -- notify caller of an error as UNEXPETED error
342: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
343: END validate_end_date;
344: --
345: -- Start of comments
346: --

Line 370: x_return_status := OKC_API.G_RET_STS_SUCCESS;

366: and U.OBJECT_code = p_rdsv_rec.JTOT_OBJECT_CODE
367: and U.object_user_code='OKX_RULES';
368: BEGIN
369: -- initialize return status
370: x_return_status := OKC_API.G_RET_STS_SUCCESS;
371:
372: -- data is required
373: IF (p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
374: p_rdsv_rec.jtot_object_code IS NULL) THEN

Line 373: IF (p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR

369: -- initialize return status
370: x_return_status := OKC_API.G_RET_STS_SUCCESS;
371:
372: -- data is required
373: IF (p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
374: p_rdsv_rec.jtot_object_code IS NULL) THEN
375: OKC_API.set_message(
376: p_app_name => G_APP_NAME,
377: p_msg_name => G_REQUIRED_VALUE,

Line 375: OKC_API.set_message(

371:
372: -- data is required
373: IF (p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
374: p_rdsv_rec.jtot_object_code IS NULL) THEN
375: OKC_API.set_message(
376: p_app_name => G_APP_NAME,
377: p_msg_name => G_REQUIRED_VALUE,
378: p_token1 => G_COL_NAME_TOKEN,
379: p_token1_value => 'jtot_object_code');

Line 382: x_return_status := OKC_API.G_RET_STS_ERROR;

378: p_token1 => G_COL_NAME_TOKEN,
379: p_token1_value => 'jtot_object_code');
380:
381: -- notify caller of an error
382: x_return_status := OKC_API.G_RET_STS_ERROR;
383:
384: -- halt validation
385: RAISE G_EXCEPTION_HALT_VALIDATION;
386: END IF;

Line 396: OKC_API.set_message(

392:
393: -- if l_dummy_var still set to default, data was not found
394: IF (l_dummy_var = '?') THEN
395: --set error message in message stack
396: OKC_API.set_message(
397: p_app_name => G_APP_NAME,
398: p_msg_name => G_INVALID_VALUE,
399: p_token1 => G_COL_NAME_TOKEN,
400: p_token1_value => 'jtot_object_code');

Line 403: x_return_status := OKC_API.G_RET_STS_ERROR;

399: p_token1 => G_COL_NAME_TOKEN,
400: p_token1_value => 'jtot_object_code');
401:
402: -- notify caller of an error
403: x_return_status := OKC_API.G_RET_STS_ERROR;
404: END IF;
405: EXCEPTION
406: WHEN G_EXCEPTION_HALT_VALIDATION THEN
407: -- no processing necessary; validation can continue with next column

Line 411: OKC_API.SET_MESSAGE(

407: -- no processing necessary; validation can continue with next column
408: NULL;
409: WHEN OTHERS THEN
410: -- store SQL error message on message stack
411: OKC_API.SET_MESSAGE(
412: p_app_name => g_app_name,
413: p_msg_name => g_unexpected_error,
414: p_token1 => g_sqlcode_token,
415: p_token1_value => sqlcode,

Line 419: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

415: p_token1_value => sqlcode,
416: p_token2 => g_sqlerrm_token,
417: p_token2_value => sqlerrm);
418: -- notify caller of an error as UNEXPETED error
419: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
420: -- verify that cursor was closed
421: IF l_jtot_csr%ISOPEN THEN
422: CLOSE l_jtot_csr;
423: END IF;

Line 468: x_return_status := OKC_API.G_RET_STS_SUCCESS;

464: l_dummy VARCHAR2(1) := '?';
465:
466: BEGIN
467: -- initialize return status
468: x_return_status := OKC_API.G_RET_STS_SUCCESS;
469:
470: -- data is required
471: IF (p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
472: p_rdsv_rec.object_id_number IS NULL) THEN

Line 471: IF (p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR

467: -- initialize return status
468: x_return_status := OKC_API.G_RET_STS_SUCCESS;
469:
470: -- data is required
471: IF (p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
472: p_rdsv_rec.object_id_number IS NULL) THEN
473: OKC_API.set_message(
474: p_app_name => G_APP_NAME,
475: p_msg_name => G_REQUIRED_VALUE,

Line 473: OKC_API.set_message(

469:
470: -- data is required
471: IF (p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
472: p_rdsv_rec.object_id_number IS NULL) THEN
473: OKC_API.set_message(
474: p_app_name => G_APP_NAME,
475: p_msg_name => G_REQUIRED_VALUE,
476: p_token1 => G_COL_NAME_TOKEN,
477: p_token1_value => 'object_id_number');

Line 480: x_return_status := OKC_API.G_RET_STS_ERROR;

476: p_token1 => G_COL_NAME_TOKEN,
477: p_token1_value => 'object_id_number');
478:
479: -- notify caller of an error
480: x_return_status := OKC_API.G_RET_STS_ERROR;
481:
482: -- halt validation
483: RAISE G_EXCEPTION_HALT_VALIDATION;
484: END IF;

Line 488: OKC_API.set_message(

484: END IF;
485:
486: -- check allowed values
487: IF (UPPER(p_rdsv_rec.object_id_number) NOT IN (1, 2, 3)) THEN
488: OKC_API.set_message(
489: p_app_name => G_APP_NAME,
490: p_msg_name => G_INVALID_VALUE,
491: p_token1 => G_COL_NAME_TOKEN,
492: p_token1_value => 'object_id_number');

Line 494: x_return_status := OKC_API.G_RET_STS_ERROR;

490: p_msg_name => G_INVALID_VALUE,
491: p_token1 => G_COL_NAME_TOKEN,
492: p_token1_value => 'object_id_number');
493: -- notify caller of an error
494: x_return_status := OKC_API.G_RET_STS_ERROR;
495: -- halt validation
496: RAISE G_EXCEPTION_HALT_VALIDATION;
497: END IF;
498:

Line 515: OKC_API.set_message(

511: OPEN l_rul_csr;
512: FETCH l_rul_csr INTO l_rule_name;
513: CLOSE l_rul_csr;
514:
515: OKC_API.set_message(
516: p_app_name => G_APP_NAME,
517: p_msg_name => G_INVALID_RULE_SOURCE,
518: p_token1 => 'RULE',
519: p_token1_value => l_rule_name,

Line 524: x_return_status := OKC_API.G_RET_STS_ERROR;

520: p_token2 => 'OBJECT_NUMBER',
521: p_token2_value => p_rdsv_rec.object_id_number);
522:
523: -- notify caller of an error
524: x_return_status := OKC_API.G_RET_STS_ERROR;
525: END IF;
526:
527: EXCEPTION
528: WHEN G_EXCEPTION_HALT_VALIDATION THEN

Line 533: OKC_API.SET_MESSAGE(

529: -- no processing necessary; validation can continue with next column
530: NULL;
531: WHEN OTHERS THEN
532: -- store SQL error message on message stack
533: OKC_API.SET_MESSAGE(
534: p_app_name => G_APP_NAME,
535: p_msg_name => G_UNEXPECTED_ERROR,
536: p_token1 => G_SQLCODE_TOKEN,
537: p_token1_value => SQLCODE,

Line 541: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

537: p_token1_value => SQLCODE,
538: p_token2 => G_SQLERRM_TOKEN,
539: p_token2_value => SQLERRM);
540: -- notify caller of an error as UNEXPETED error
541: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
542: -- verify that cursor was closed
543: IF l_dfcu_csr%ISOPEN THEN
544: CLOSE l_dfcu_csr;
545: END IF;

Line 564: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

560: PROCEDURE check_unique(
561: x_return_status OUT NOCOPY VARCHAR2,
562: p_rdsv_rec IN rdsv_rec_type
563: ) IS
564: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
565: l_dummy NUMBER;
566: BEGIN
567: -- initialize return status
568: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 568: x_return_status := OKC_API.G_RET_STS_SUCCESS;

564: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
565: l_dummy NUMBER;
566: BEGIN
567: -- initialize return status
568: x_return_status := OKC_API.G_RET_STS_SUCCESS;
569:
570:
571: SELECT COUNT(1)
572: INTO l_dummy

Line 590: OKC_API.set_message(

586: AND ((p_rdsv_rec.row_id IS NULL) OR (ROWID <> p_rdsv_rec.row_id));
587:
588: IF (l_dummy >= 1) then
589: --set error message in message stack
590: OKC_API.set_message(
591: p_app_name => G_APP_NAME,
592: p_msg_name => G_TOO_MANY_SOURCES,
593: p_token1 => 'SOURCE',
594: p_token1_value => 'Rule Type Source',

Line 599: x_return_status := OKC_API.G_RET_STS_ERROR;

595: p_token2 => 'DATE',
596: p_token2_value => p_rdsv_rec.start_date);
597:
598: -- notify caller of an error
599: x_return_status := OKC_API.G_RET_STS_ERROR;
600: END IF;
601:
602:
603: EXCEPTION

Line 606: OKC_API.SET_MESSAGE(

602:
603: EXCEPTION
604: WHEN OTHERS THEN
605: -- store SQL error message on message stack
606: OKC_API.SET_MESSAGE(
607: p_app_name => G_APP_NAME,
608: p_msg_name => G_UNEXPECTED_ERROR,
609: p_token1 => G_SQLCODE_TOKEN,
610: p_token1_value => SQLCODE,

Line 614: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

610: p_token1_value => SQLCODE,
611: p_token2 => G_SQLERRM_TOKEN,
612: p_token2_value => SQLERRM);
613: -- notify caller of an error as UNEXPETED error
614: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
615: END check_unique;
616: --
617:
618:

Line 652: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

648: AND buy_or_sell = p_rdsv_rec.BUY_OR_SELL
649: AND TRUNC(start_date) = TO_CHAR(TRUNC(p_rdsv_rec.start_date),'DD-MON-YYYY')
650: AND object_id_number = p_rdsv_rec.OBJECT_ID_NUMBER;
651:
652: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
653: l_row_found BOOLEAN := FALSE;
654: l_dummy VARCHAR2(1);
655:
656: BEGIN

Line 658: x_return_status := OKC_API.G_RET_STS_SUCCESS;

654: l_dummy VARCHAR2(1);
655:
656: BEGIN
657: -- initialize return status
658: x_return_status := OKC_API.G_RET_STS_SUCCESS;
659:
660: -- ---------------------------------------------------------------------
661: -- Bug 1636056 related changes - Shyam
662: -- OKC_UTIL.check_comp_unique call is replaced with

Line 669: AND (p_rdsv_rec.RGR_RDF_CODE <> OKC_API.G_MISS_CHAR) )

665: -- START_DATE + OBJECT_ID_NUMBER
666: -- in OKC_RULE_DEF_SOURCES_V
667: -- ---------------------------------------------------------------------
668: IF ( (p_rdsv_rec.RGR_RDF_CODE IS NOT NULL)
669: AND (p_rdsv_rec.RGR_RDF_CODE <> OKC_API.G_MISS_CHAR) )
670: AND
671: ( (p_rdsv_rec.RGR_RGD_CODE IS NOT NULL)
672: AND (p_rdsv_rec.RGR_RGD_CODE <> OKC_API.G_MISS_CHAR) )
673: AND

Line 672: AND (p_rdsv_rec.RGR_RGD_CODE <> OKC_API.G_MISS_CHAR) )

668: IF ( (p_rdsv_rec.RGR_RDF_CODE IS NOT NULL)
669: AND (p_rdsv_rec.RGR_RDF_CODE <> OKC_API.G_MISS_CHAR) )
670: AND
671: ( (p_rdsv_rec.RGR_RGD_CODE IS NOT NULL)
672: AND (p_rdsv_rec.RGR_RGD_CODE <> OKC_API.G_MISS_CHAR) )
673: AND
674: ( (p_rdsv_rec.BUY_OR_SELL IS NOT NULL)
675: AND (p_rdsv_rec.BUY_OR_SELL <> OKC_API.G_MISS_CHAR) )
676: AND

Line 675: AND (p_rdsv_rec.BUY_OR_SELL <> OKC_API.G_MISS_CHAR) )

671: ( (p_rdsv_rec.RGR_RGD_CODE IS NOT NULL)
672: AND (p_rdsv_rec.RGR_RGD_CODE <> OKC_API.G_MISS_CHAR) )
673: AND
674: ( (p_rdsv_rec.BUY_OR_SELL IS NOT NULL)
675: AND (p_rdsv_rec.BUY_OR_SELL <> OKC_API.G_MISS_CHAR) )
676: AND
677: ( (p_rdsv_rec.START_DATE IS NOT NULL)
678: AND (p_rdsv_rec.START_DATE <> OKC_API.G_MISS_DATE) )
679: AND

Line 678: AND (p_rdsv_rec.START_DATE <> OKC_API.G_MISS_DATE) )

674: ( (p_rdsv_rec.BUY_OR_SELL IS NOT NULL)
675: AND (p_rdsv_rec.BUY_OR_SELL <> OKC_API.G_MISS_CHAR) )
676: AND
677: ( (p_rdsv_rec.START_DATE IS NOT NULL)
678: AND (p_rdsv_rec.START_DATE <> OKC_API.G_MISS_DATE) )
679: AND
680: ( (p_rdsv_rec.OBJECT_ID_NUMBER IS NOT NULL)
681: AND (p_rdsv_rec.OBJECT_ID_NUMBER <> OKC_API.G_MISS_NUM) )
682: THEN

Line 681: AND (p_rdsv_rec.OBJECT_ID_NUMBER <> OKC_API.G_MISS_NUM) )

677: ( (p_rdsv_rec.START_DATE IS NOT NULL)
678: AND (p_rdsv_rec.START_DATE <> OKC_API.G_MISS_DATE) )
679: AND
680: ( (p_rdsv_rec.OBJECT_ID_NUMBER IS NOT NULL)
681: AND (p_rdsv_rec.OBJECT_ID_NUMBER <> OKC_API.G_MISS_NUM) )
682: THEN
683: OPEN cur_rds;
684: FETCH cur_rds INTO l_dummy;
685: l_row_found := cur_rds%FOUND;

Line 691: OKC_API.set_message(G_APP_NAME,

687:
688: IF (l_row_found)
689: THEN
690: -- Display the newly defined error message
691: OKC_API.set_message(G_APP_NAME,
692: 'OKC_DUP_RULE_DEF_SOURCE');
693:
694: -- If not unique, set error flag
695: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 695: x_return_status := OKC_API.G_RET_STS_ERROR;

691: OKC_API.set_message(G_APP_NAME,
692: 'OKC_DUP_RULE_DEF_SOURCE');
693:
694: -- If not unique, set error flag
695: x_return_status := OKC_API.G_RET_STS_ERROR;
696: END IF;
697: END IF;
698:
699: EXCEPTION

Line 702: OKC_API.SET_MESSAGE( p_app_name => G_APP_NAME,

698:
699: EXCEPTION
700: WHEN OTHERS THEN
701: -- store SQL error message on message stack
702: OKC_API.SET_MESSAGE( p_app_name => G_APP_NAME,
703: p_msg_name => G_UNEXPECTED_ERROR,
704: p_token1 => G_SQLCODE_TOKEN,
705: p_token1_value => SQLCODE,
706: p_token2 => G_SQLERRM_TOKEN,

Line 710: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

706: p_token2 => G_SQLERRM_TOKEN,
707: p_token2_value => SQLERRM);
708:
709: -- notify caller of an error as UNEXPETED error
710: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
711: END validate_uniqueness;
712:
713: <------------ END COMMENTED SEGMENT --------------->
714: */

Line 729: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

725:
726: FUNCTION Validate_Attributes (
727: p_rdsv_rec IN rdsv_rec_type
728: ) RETURN VARCHAR2 IS
729: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
730: x_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
731: BEGIN
732: -- call each column-level validation
733: validate_rgr_codes(

Line 730: x_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

726: FUNCTION Validate_Attributes (
727: p_rdsv_rec IN rdsv_rec_type
728: ) RETURN VARCHAR2 IS
729: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
730: x_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
731: BEGIN
732: -- call each column-level validation
733: validate_rgr_codes(
734: x_return_status => l_return_status,

Line 738: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

734: x_return_status => l_return_status,
735: p_rdsv_rec => p_rdsv_rec);
736:
737: -- store the highest degree of error
738: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
739: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
740: x_return_status := l_return_status;
741: END IF;
742: END IF;

Line 739: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

735: p_rdsv_rec => p_rdsv_rec);
736:
737: -- store the highest degree of error
738: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
739: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
740: x_return_status := l_return_status;
741: END IF;
742: END IF;
743: --

Line 749: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

745: x_return_status => l_return_status,
746: p_rdsv_rec => p_rdsv_rec);
747:
748: -- store the highest degree of error
749: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
750: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
751: x_return_status := l_return_status;
752: END IF;
753: END IF;

Line 750: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

746: p_rdsv_rec => p_rdsv_rec);
747:
748: -- store the highest degree of error
749: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
750: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
751: x_return_status := l_return_status;
752: END IF;
753: END IF;
754: --

Line 760: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

756: x_return_status => l_return_status,
757: p_rdsv_rec => p_rdsv_rec);
758:
759: -- store the highest degree of error
760: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
761: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
762: x_return_status := l_return_status;
763: END IF;
764: END IF;

Line 761: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

757: p_rdsv_rec => p_rdsv_rec);
758:
759: -- store the highest degree of error
760: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
761: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
762: x_return_status := l_return_status;
763: END IF;
764: END IF;
765: --

Line 772: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

768: x_return_status => l_return_status,
769: p_rdsv_rec => p_rdsv_rec);
770:
771: -- store the highest degree of error
772: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
773: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
774: x_return_status := l_return_status;
775: END IF;
776: END IF;

Line 773: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

769: p_rdsv_rec => p_rdsv_rec);
770:
771: -- store the highest degree of error
772: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
773: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
774: x_return_status := l_return_status;
775: END IF;
776: END IF;
777: --

Line 783: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

779: x_return_status => l_return_status,
780: p_rdsv_rec => p_rdsv_rec);
781:
782: -- store the highest degree of error
783: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
784: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
785: x_return_status := l_return_status;
786: END IF;
787: END IF;

Line 784: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

780: p_rdsv_rec => p_rdsv_rec);
781:
782: -- store the highest degree of error
783: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
784: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
785: x_return_status := l_return_status;
786: END IF;
787: END IF;
788: --

Line 794: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

790: x_return_status => l_return_status,
791: p_rdsv_rec => p_rdsv_rec);
792:
793: -- store the highest degree of error
794: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
795: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
796: x_return_status := l_return_status;
797: END IF;
798: END IF;

Line 795: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

791: p_rdsv_rec => p_rdsv_rec);
792:
793: -- store the highest degree of error
794: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
795: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
796: x_return_status := l_return_status;
797: END IF;
798: END IF;
799: --

Line 805: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

801: x_return_status => l_return_status,
802: p_rdsv_rec => p_rdsv_rec);
803:
804: -- store the highest degree of error
805: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
806: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
807: x_return_status := l_return_status;
808: END IF;
809: END IF;

Line 806: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

802: p_rdsv_rec => p_rdsv_rec);
803:
804: -- store the highest degree of error
805: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
806: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
807: x_return_status := l_return_status;
808: END IF;
809: END IF;
810: --

Line 816: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

812: x_return_status => l_return_status,
813: p_rdsv_rec => p_rdsv_rec);
814:
815: -- store the highest degree of error
816: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
817: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
818: x_return_status := l_return_status;
819: END IF;
820: END IF;

Line 817: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN

813: p_rdsv_rec => p_rdsv_rec);
814:
815: -- store the highest degree of error
816: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
817: IF (x_return_status <> OKC_API.G_RET_STS_UNEXP_ERROR) THEN
818: x_return_status := l_return_status;
819: END IF;
820: END IF;
821: --

Line 828: OKC_API.SET_MESSAGE

824:
825: EXCEPTION
826: WHEN OTHERS THEN
827: -- store SQL error message on message stack for caller
828: OKC_API.SET_MESSAGE
829: (p_app_name => G_APP_NAME,
830: p_msg_name => G_UNEXPECTED_ERROR,
831: p_token1 => G_SQLCODE_TOKEN,
832: p_token1_value => SQLCODE,

Line 837: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

833: p_token2 => G_SQLERRM_TOKEN,
834: p_token2_value => SQLERRM);
835:
836: -- notify caller of an UNEXPECTED error
837: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
838:
839: -- return status to caller
840: RETURN x_return_status;
841:

Line 1027: IF (l_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) THEN

1023: p_rdsv_rec IN rdsv_rec_type
1024: ) RETURN rdsv_rec_type IS
1025: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
1026: BEGIN
1027: IF (l_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) THEN
1028: l_rdsv_rec.jtot_object_code := NULL;
1029: END IF;
1030: IF (l_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR) THEN
1031: l_rdsv_rec.rgr_rgd_code := NULL;

Line 1030: IF (l_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR) THEN

1026: BEGIN
1027: IF (l_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) THEN
1028: l_rdsv_rec.jtot_object_code := NULL;
1029: END IF;
1030: IF (l_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR) THEN
1031: l_rdsv_rec.rgr_rgd_code := NULL;
1032: END IF;
1033: IF (l_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR) THEN
1034: l_rdsv_rec.rgr_rdf_code := NULL;

Line 1033: IF (l_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR) THEN

1029: END IF;
1030: IF (l_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR) THEN
1031: l_rdsv_rec.rgr_rgd_code := NULL;
1032: END IF;
1033: IF (l_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR) THEN
1034: l_rdsv_rec.rgr_rdf_code := NULL;
1035: END IF;
1036: IF (l_rdsv_rec.end_date = OKC_API.G_MISS_DATE) THEN
1037: l_rdsv_rec.end_date := NULL;

Line 1036: IF (l_rdsv_rec.end_date = OKC_API.G_MISS_DATE) THEN

1032: END IF;
1033: IF (l_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR) THEN
1034: l_rdsv_rec.rgr_rdf_code := NULL;
1035: END IF;
1036: IF (l_rdsv_rec.end_date = OKC_API.G_MISS_DATE) THEN
1037: l_rdsv_rec.end_date := NULL;
1038: END IF;
1039: IF (l_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
1040: l_rdsv_rec.object_version_number := NULL;

Line 1039: IF (l_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN

1035: END IF;
1036: IF (l_rdsv_rec.end_date = OKC_API.G_MISS_DATE) THEN
1037: l_rdsv_rec.end_date := NULL;
1038: END IF;
1039: IF (l_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
1040: l_rdsv_rec.object_version_number := NULL;
1041: END IF;
1042: IF (l_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM) THEN
1043: l_rdsv_rec.object_id_number := NULL;

Line 1042: IF (l_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM) THEN

1038: END IF;
1039: IF (l_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
1040: l_rdsv_rec.object_version_number := NULL;
1041: END IF;
1042: IF (l_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM) THEN
1043: l_rdsv_rec.object_id_number := NULL;
1044: END IF;
1045: IF (l_rdsv_rec.created_by = OKC_API.G_MISS_NUM) THEN
1046: l_rdsv_rec.created_by := NULL;

Line 1045: IF (l_rdsv_rec.created_by = OKC_API.G_MISS_NUM) THEN

1041: END IF;
1042: IF (l_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM) THEN
1043: l_rdsv_rec.object_id_number := NULL;
1044: END IF;
1045: IF (l_rdsv_rec.created_by = OKC_API.G_MISS_NUM) THEN
1046: l_rdsv_rec.created_by := NULL;
1047: END IF;
1048: IF (l_rdsv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
1049: l_rdsv_rec.creation_date := NULL;

Line 1048: IF (l_rdsv_rec.creation_date = OKC_API.G_MISS_DATE) THEN

1044: END IF;
1045: IF (l_rdsv_rec.created_by = OKC_API.G_MISS_NUM) THEN
1046: l_rdsv_rec.created_by := NULL;
1047: END IF;
1048: IF (l_rdsv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
1049: l_rdsv_rec.creation_date := NULL;
1050: END IF;
1051: IF (l_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
1052: l_rdsv_rec.last_updated_by := NULL;

Line 1051: IF (l_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN

1047: END IF;
1048: IF (l_rdsv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
1049: l_rdsv_rec.creation_date := NULL;
1050: END IF;
1051: IF (l_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
1052: l_rdsv_rec.last_updated_by := NULL;
1053: END IF;
1054: IF (l_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
1055: l_rdsv_rec.last_update_date := NULL;

Line 1054: IF (l_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN

1050: END IF;
1051: IF (l_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
1052: l_rdsv_rec.last_updated_by := NULL;
1053: END IF;
1054: IF (l_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
1055: l_rdsv_rec.last_update_date := NULL;
1056: END IF;
1057: IF (l_rdsv_rec.last_update_login = OKC_API.G_MISS_NUM) THEN
1058: l_rdsv_rec.last_update_login := NULL;

Line 1057: IF (l_rdsv_rec.last_update_login = OKC_API.G_MISS_NUM) THEN

1053: END IF;
1054: IF (l_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
1055: l_rdsv_rec.last_update_date := NULL;
1056: END IF;
1057: IF (l_rdsv_rec.last_update_login = OKC_API.G_MISS_NUM) THEN
1058: l_rdsv_rec.last_update_login := NULL;
1059: END IF;
1060: RETURN(l_rdsv_rec);
1061: END null_out_defaults;

Line 1072: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1068: /* commenting out nocopy generated code in favor of hand-coded procedure
1069: FUNCTION Validate_Attributes (
1070: p_rdsv_rec IN rdsv_rec_type
1071: ) RETURN VARCHAR2 IS
1072: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1073: BEGIN
1074: IF p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
1075: p_rdsv_rec.jtot_object_code IS NULL
1076: THEN

Line 1074: IF p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR

1070: p_rdsv_rec IN rdsv_rec_type
1071: ) RETURN VARCHAR2 IS
1072: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1073: BEGIN
1074: IF p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
1075: p_rdsv_rec.jtot_object_code IS NULL
1076: THEN
1077: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'jtot_object_code');
1078: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 1077: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'jtot_object_code');

1073: BEGIN
1074: IF p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
1075: p_rdsv_rec.jtot_object_code IS NULL
1076: THEN
1077: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'jtot_object_code');
1078: l_return_status := OKC_API.G_RET_STS_ERROR;
1079: ELSIF p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
1080: p_rdsv_rec.rgr_rgd_code IS NULL
1081: THEN

Line 1078: l_return_status := OKC_API.G_RET_STS_ERROR;

1074: IF p_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
1075: p_rdsv_rec.jtot_object_code IS NULL
1076: THEN
1077: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'jtot_object_code');
1078: l_return_status := OKC_API.G_RET_STS_ERROR;
1079: ELSIF p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
1080: p_rdsv_rec.rgr_rgd_code IS NULL
1081: THEN
1082: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rgd_code');

Line 1079: ELSIF p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR

1075: p_rdsv_rec.jtot_object_code IS NULL
1076: THEN
1077: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'jtot_object_code');
1078: l_return_status := OKC_API.G_RET_STS_ERROR;
1079: ELSIF p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
1080: p_rdsv_rec.rgr_rgd_code IS NULL
1081: THEN
1082: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rgd_code');
1083: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 1082: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rgd_code');

1078: l_return_status := OKC_API.G_RET_STS_ERROR;
1079: ELSIF p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
1080: p_rdsv_rec.rgr_rgd_code IS NULL
1081: THEN
1082: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rgd_code');
1083: l_return_status := OKC_API.G_RET_STS_ERROR;
1084: ELSIF p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR
1085: p_rdsv_rec.rgr_rdf_code IS NULL
1086: THEN

Line 1083: l_return_status := OKC_API.G_RET_STS_ERROR;

1079: ELSIF p_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR OR
1080: p_rdsv_rec.rgr_rgd_code IS NULL
1081: THEN
1082: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rgd_code');
1083: l_return_status := OKC_API.G_RET_STS_ERROR;
1084: ELSIF p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR
1085: p_rdsv_rec.rgr_rdf_code IS NULL
1086: THEN
1087: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rdf_code');

Line 1084: ELSIF p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR

1080: p_rdsv_rec.rgr_rgd_code IS NULL
1081: THEN
1082: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rgd_code');
1083: l_return_status := OKC_API.G_RET_STS_ERROR;
1084: ELSIF p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR
1085: p_rdsv_rec.rgr_rdf_code IS NULL
1086: THEN
1087: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rdf_code');
1088: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 1087: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rdf_code');

1083: l_return_status := OKC_API.G_RET_STS_ERROR;
1084: ELSIF p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR
1085: p_rdsv_rec.rgr_rdf_code IS NULL
1086: THEN
1087: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rdf_code');
1088: l_return_status := OKC_API.G_RET_STS_ERROR;
1089: ELSIF p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
1090: p_rdsv_rec.buy_or_sell IS NULL
1091: THEN

Line 1088: l_return_status := OKC_API.G_RET_STS_ERROR;

1084: ELSIF p_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR OR
1085: p_rdsv_rec.rgr_rdf_code IS NULL
1086: THEN
1087: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rdf_code');
1088: l_return_status := OKC_API.G_RET_STS_ERROR;
1089: ELSIF p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
1090: p_rdsv_rec.buy_or_sell IS NULL
1091: THEN
1092: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');

Line 1089: ELSIF p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR

1085: p_rdsv_rec.rgr_rdf_code IS NULL
1086: THEN
1087: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rgr_rdf_code');
1088: l_return_status := OKC_API.G_RET_STS_ERROR;
1089: ELSIF p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
1090: p_rdsv_rec.buy_or_sell IS NULL
1091: THEN
1092: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
1093: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 1092: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');

1088: l_return_status := OKC_API.G_RET_STS_ERROR;
1089: ELSIF p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
1090: p_rdsv_rec.buy_or_sell IS NULL
1091: THEN
1092: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
1093: l_return_status := OKC_API.G_RET_STS_ERROR;
1094: ELSIF p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
1095: p_rdsv_rec.start_date IS NULL
1096: THEN

Line 1093: l_return_status := OKC_API.G_RET_STS_ERROR;

1089: ELSIF p_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
1090: p_rdsv_rec.buy_or_sell IS NULL
1091: THEN
1092: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
1093: l_return_status := OKC_API.G_RET_STS_ERROR;
1094: ELSIF p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
1095: p_rdsv_rec.start_date IS NULL
1096: THEN
1097: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');

Line 1094: ELSIF p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR

1090: p_rdsv_rec.buy_or_sell IS NULL
1091: THEN
1092: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
1093: l_return_status := OKC_API.G_RET_STS_ERROR;
1094: ELSIF p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
1095: p_rdsv_rec.start_date IS NULL
1096: THEN
1097: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
1098: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 1097: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');

1093: l_return_status := OKC_API.G_RET_STS_ERROR;
1094: ELSIF p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
1095: p_rdsv_rec.start_date IS NULL
1096: THEN
1097: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
1098: l_return_status := OKC_API.G_RET_STS_ERROR;
1099: ELSIF p_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM OR
1100: p_rdsv_rec.object_version_number IS NULL
1101: THEN

Line 1098: l_return_status := OKC_API.G_RET_STS_ERROR;

1094: ELSIF p_rdsv_rec.start_date = OKC_API.G_MISS_DATE OR
1095: p_rdsv_rec.start_date IS NULL
1096: THEN
1097: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
1098: l_return_status := OKC_API.G_RET_STS_ERROR;
1099: ELSIF p_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM OR
1100: p_rdsv_rec.object_version_number IS NULL
1101: THEN
1102: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');

Line 1099: ELSIF p_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM OR

1095: p_rdsv_rec.start_date IS NULL
1096: THEN
1097: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
1098: l_return_status := OKC_API.G_RET_STS_ERROR;
1099: ELSIF p_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM OR
1100: p_rdsv_rec.object_version_number IS NULL
1101: THEN
1102: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
1103: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 1102: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');

1098: l_return_status := OKC_API.G_RET_STS_ERROR;
1099: ELSIF p_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM OR
1100: p_rdsv_rec.object_version_number IS NULL
1101: THEN
1102: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
1103: l_return_status := OKC_API.G_RET_STS_ERROR;
1104: ELSIF p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
1105: p_rdsv_rec.object_id_number IS NULL
1106: THEN

Line 1103: l_return_status := OKC_API.G_RET_STS_ERROR;

1099: ELSIF p_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM OR
1100: p_rdsv_rec.object_version_number IS NULL
1101: THEN
1102: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
1103: l_return_status := OKC_API.G_RET_STS_ERROR;
1104: ELSIF p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
1105: p_rdsv_rec.object_id_number IS NULL
1106: THEN
1107: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_id_number');

Line 1104: ELSIF p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR

1100: p_rdsv_rec.object_version_number IS NULL
1101: THEN
1102: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
1103: l_return_status := OKC_API.G_RET_STS_ERROR;
1104: ELSIF p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
1105: p_rdsv_rec.object_id_number IS NULL
1106: THEN
1107: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_id_number');
1108: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 1107: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_id_number');

1103: l_return_status := OKC_API.G_RET_STS_ERROR;
1104: ELSIF p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
1105: p_rdsv_rec.object_id_number IS NULL
1106: THEN
1107: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_id_number');
1108: l_return_status := OKC_API.G_RET_STS_ERROR;
1109: END IF;
1110: RETURN(l_return_status);
1111: END Validate_Attributes;

Line 1108: l_return_status := OKC_API.G_RET_STS_ERROR;

1104: ELSIF p_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM OR
1105: p_rdsv_rec.object_id_number IS NULL
1106: THEN
1107: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_id_number');
1108: l_return_status := OKC_API.G_RET_STS_ERROR;
1109: END IF;
1110: RETURN(l_return_status);
1111: END Validate_Attributes;
1112: */

Line 1122: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1118: ------------------------------------------------
1119: FUNCTION Validate_Record (
1120: p_rdsv_rec IN rdsv_rec_type
1121: ) RETURN VARCHAR2 IS
1122: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1123: BEGIN
1124: RETURN (l_return_status);
1125: END Validate_Record;
1126:

Line 1187: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1183: p_rdsv_rec IN rdsv_rec_type) IS
1184:
1185: l_api_version CONSTANT NUMBER := 1;
1186: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_row';
1187: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1188: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
1189: l_rds_rec rds_rec_type;
1190: BEGIN
1191: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 1191: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1187: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1188: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
1189: l_rds_rec rds_rec_type;
1190: BEGIN
1191: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1192: G_PKG_NAME,
1193: p_init_msg_list,
1194: l_api_version,
1195: p_api_version,

Line 1198: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1194: l_api_version,
1195: p_api_version,
1196: '_PVT',
1197: x_return_status);
1198: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;

Line 1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1195: p_api_version,
1196: '_PVT',
1197: x_return_status);
1198: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;
1203: --- Validate all non-missing attributes (Item Level Validation)

Line 1200: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1196: '_PVT',
1197: x_return_status);
1198: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;
1203: --- Validate all non-missing attributes (Item Level Validation)
1204: l_return_status := Validate_Attributes(l_rdsv_rec);

Line 1201: RAISE OKC_API.G_EXCEPTION_ERROR;

1197: x_return_status);
1198: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1200: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1201: RAISE OKC_API.G_EXCEPTION_ERROR;
1202: END IF;
1203: --- Validate all non-missing attributes (Item Level Validation)
1204: l_return_status := Validate_Attributes(l_rdsv_rec);
1205: --- If any errors happen abort API

Line 1206: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1202: END IF;
1203: --- Validate all non-missing attributes (Item Level Validation)
1204: l_return_status := Validate_Attributes(l_rdsv_rec);
1205: --- If any errors happen abort API
1206: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1207: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1208: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1209: RAISE OKC_API.G_EXCEPTION_ERROR;
1210: END IF;

Line 1207: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1203: --- Validate all non-missing attributes (Item Level Validation)
1204: l_return_status := Validate_Attributes(l_rdsv_rec);
1205: --- If any errors happen abort API
1206: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1207: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1208: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1209: RAISE OKC_API.G_EXCEPTION_ERROR;
1210: END IF;
1211: l_return_status := Validate_Record(l_rdsv_rec);

Line 1208: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1204: l_return_status := Validate_Attributes(l_rdsv_rec);
1205: --- If any errors happen abort API
1206: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1207: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1208: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1209: RAISE OKC_API.G_EXCEPTION_ERROR;
1210: END IF;
1211: l_return_status := Validate_Record(l_rdsv_rec);
1212: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1209: RAISE OKC_API.G_EXCEPTION_ERROR;

1205: --- If any errors happen abort API
1206: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1207: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1208: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1209: RAISE OKC_API.G_EXCEPTION_ERROR;
1210: END IF;
1211: l_return_status := Validate_Record(l_rdsv_rec);
1212: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

Line 1212: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1208: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1209: RAISE OKC_API.G_EXCEPTION_ERROR;
1210: END IF;
1211: l_return_status := Validate_Record(l_rdsv_rec);
1212: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;

Line 1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1209: RAISE OKC_API.G_EXCEPTION_ERROR;
1210: END IF;
1211: l_return_status := Validate_Record(l_rdsv_rec);
1212: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1214: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1210: END IF;
1211: l_return_status := Validate_Record(l_rdsv_rec);
1212: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1218: EXCEPTION

Line 1215: RAISE OKC_API.G_EXCEPTION_ERROR;

1211: l_return_status := Validate_Record(l_rdsv_rec);
1212: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1218: EXCEPTION
1219: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 1217: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1213: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1214: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1218: EXCEPTION
1219: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1220: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1221: (

Line 1219: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1215: RAISE OKC_API.G_EXCEPTION_ERROR;
1216: END IF;
1217: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1218: EXCEPTION
1219: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1220: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1221: (
1222: l_api_name,
1223: G_PKG_NAME,

Line 1220: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1216: END IF;
1217: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1218: EXCEPTION
1219: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1220: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1221: (
1222: l_api_name,
1223: G_PKG_NAME,
1224: 'OKC_API.G_RET_STS_ERROR',

Line 1224: 'OKC_API.G_RET_STS_ERROR',

1220: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1221: (
1222: l_api_name,
1223: G_PKG_NAME,
1224: 'OKC_API.G_RET_STS_ERROR',
1225: x_msg_count,
1226: x_msg_data,
1227: '_PVT'
1228: );

Line 1229: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1225: x_msg_count,
1226: x_msg_data,
1227: '_PVT'
1228: );
1229: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1230: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1231: (
1232: l_api_name,
1233: G_PKG_NAME,

Line 1230: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1226: x_msg_data,
1227: '_PVT'
1228: );
1229: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1230: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1231: (
1232: l_api_name,
1233: G_PKG_NAME,
1234: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1234: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1230: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1231: (
1232: l_api_name,
1233: G_PKG_NAME,
1234: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1235: x_msg_count,
1236: x_msg_data,
1237: '_PVT'
1238: );

Line 1240: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1236: x_msg_data,
1237: '_PVT'
1238: );
1239: WHEN OTHERS THEN
1240: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1241: (
1242: l_api_name,
1243: G_PKG_NAME,
1244: 'OTHERS',

Line 1263: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1259: p_rdsv_tbl IN rdsv_tbl_type) IS
1260:
1261: l_api_version CONSTANT NUMBER := 1;
1262: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
1263: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1264: i NUMBER := 0;
1265: BEGIN
1266: OKC_API.init_msg_list(p_init_msg_list);
1267: -- Make sure PL/SQL table has records in it before passing

Line 1266: OKC_API.init_msg_list(p_init_msg_list);

1262: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
1263: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1264: i NUMBER := 0;
1265: BEGIN
1266: OKC_API.init_msg_list(p_init_msg_list);
1267: -- Make sure PL/SQL table has records in it before passing
1268: IF (p_rdsv_tbl.COUNT > 0) THEN
1269: i := p_rdsv_tbl.FIRST;
1270: LOOP

Line 1273: p_init_msg_list => OKC_API.G_FALSE,

1269: i := p_rdsv_tbl.FIRST;
1270: LOOP
1271: validate_row (
1272: p_api_version => p_api_version,
1273: p_init_msg_list => OKC_API.G_FALSE,
1274: x_return_status => x_return_status,
1275: x_msg_count => x_msg_count,
1276: x_msg_data => x_msg_data,
1277: p_rdsv_rec => p_rdsv_tbl(i));

Line 1283: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1279: i := p_rdsv_tbl.NEXT(i);
1280: END LOOP;
1281: END IF;
1282: EXCEPTION
1283: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1284: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1285: (
1286: l_api_name,
1287: G_PKG_NAME,

Line 1284: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1280: END LOOP;
1281: END IF;
1282: EXCEPTION
1283: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1284: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1285: (
1286: l_api_name,
1287: G_PKG_NAME,
1288: 'OKC_API.G_RET_STS_ERROR',

Line 1288: 'OKC_API.G_RET_STS_ERROR',

1284: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1285: (
1286: l_api_name,
1287: G_PKG_NAME,
1288: 'OKC_API.G_RET_STS_ERROR',
1289: x_msg_count,
1290: x_msg_data,
1291: '_PVT'
1292: );

Line 1293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1289: x_msg_count,
1290: x_msg_data,
1291: '_PVT'
1292: );
1293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1294: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1295: (
1296: l_api_name,
1297: G_PKG_NAME,

Line 1294: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1290: x_msg_data,
1291: '_PVT'
1292: );
1293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1294: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1295: (
1296: l_api_name,
1297: G_PKG_NAME,
1298: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1298: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1294: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1295: (
1296: l_api_name,
1297: G_PKG_NAME,
1298: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1299: x_msg_count,
1300: x_msg_data,
1301: '_PVT'
1302: );

Line 1304: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1300: x_msg_data,
1301: '_PVT'
1302: );
1303: WHEN OTHERS THEN
1304: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1305: (
1306: l_api_name,
1307: G_PKG_NAME,
1308: 'OTHERS',

Line 1331: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1327: x_rds_rec OUT NOCOPY rds_rec_type) IS
1328:
1329: l_api_version CONSTANT NUMBER := 1;
1330: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_insert_row';
1331: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1332: l_rds_rec rds_rec_type := p_rds_rec;
1333: l_def_rds_rec rds_rec_type;
1334: ---------------------------------------------
1335: -- Set_Attributes for:OKC_RULE_DEF_SOURCES --

Line 1341: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1337: FUNCTION Set_Attributes (
1338: p_rds_rec IN rds_rec_type,
1339: x_rds_rec OUT NOCOPY rds_rec_type
1340: ) RETURN VARCHAR2 IS
1341: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1342: BEGIN
1343: x_rds_rec := p_rds_rec;
1344: RETURN(l_return_status);
1345: END Set_Attributes;

Line 1347: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1343: x_rds_rec := p_rds_rec;
1344: RETURN(l_return_status);
1345: END Set_Attributes;
1346: BEGIN
1347: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1348: p_init_msg_list,
1349: '_PVT',
1350: x_return_status);
1351: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1351: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1347: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1348: p_init_msg_list,
1349: '_PVT',
1350: x_return_status);
1351: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1352: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1353: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1354: RAISE OKC_API.G_EXCEPTION_ERROR;
1355: END IF;

Line 1352: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1348: p_init_msg_list,
1349: '_PVT',
1350: x_return_status);
1351: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1352: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1353: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1354: RAISE OKC_API.G_EXCEPTION_ERROR;
1355: END IF;
1356: --- Setting item attributes

Line 1353: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1349: '_PVT',
1350: x_return_status);
1351: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1352: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1353: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1354: RAISE OKC_API.G_EXCEPTION_ERROR;
1355: END IF;
1356: --- Setting item attributes
1357: l_return_status := Set_Attributes(

Line 1354: RAISE OKC_API.G_EXCEPTION_ERROR;

1350: x_return_status);
1351: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1352: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1353: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1354: RAISE OKC_API.G_EXCEPTION_ERROR;
1355: END IF;
1356: --- Setting item attributes
1357: l_return_status := Set_Attributes(
1358: p_rds_rec, -- IN

Line 1361: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1357: l_return_status := Set_Attributes(
1358: p_rds_rec, -- IN
1359: l_rds_rec); -- OUT
1360: --- If any errors happen abort API
1361: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;

Line 1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1358: p_rds_rec, -- IN
1359: l_rds_rec); -- OUT
1360: --- If any errors happen abort API
1361: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;
1366: INSERT INTO OKC_RULE_DEF_SOURCES(

Line 1363: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1359: l_rds_rec); -- OUT
1360: --- If any errors happen abort API
1361: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;
1366: INSERT INTO OKC_RULE_DEF_SOURCES(
1367: rgr_rgd_code,

Line 1364: RAISE OKC_API.G_EXCEPTION_ERROR;

1360: --- If any errors happen abort API
1361: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;
1366: INSERT INTO OKC_RULE_DEF_SOURCES(
1367: rgr_rgd_code,
1368: rgr_rdf_code,

Line 1398: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1394: l_rds_rec.last_update_date,
1395: l_rds_rec.last_update_login);
1396: -- Set OUT values
1397: x_rds_rec := l_rds_rec;
1398: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1399: EXCEPTION
1400: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1401: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1402: (

Line 1400: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1396: -- Set OUT values
1397: x_rds_rec := l_rds_rec;
1398: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1399: EXCEPTION
1400: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1401: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1402: (
1403: l_api_name,
1404: G_PKG_NAME,

Line 1401: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1397: x_rds_rec := l_rds_rec;
1398: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1399: EXCEPTION
1400: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1401: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1402: (
1403: l_api_name,
1404: G_PKG_NAME,
1405: 'OKC_API.G_RET_STS_ERROR',

Line 1405: 'OKC_API.G_RET_STS_ERROR',

1401: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1402: (
1403: l_api_name,
1404: G_PKG_NAME,
1405: 'OKC_API.G_RET_STS_ERROR',
1406: x_msg_count,
1407: x_msg_data,
1408: '_PVT'
1409: );

Line 1410: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1406: x_msg_count,
1407: x_msg_data,
1408: '_PVT'
1409: );
1410: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1411: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1412: (
1413: l_api_name,
1414: G_PKG_NAME,

Line 1411: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1407: x_msg_data,
1408: '_PVT'
1409: );
1410: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1411: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1412: (
1413: l_api_name,
1414: G_PKG_NAME,
1415: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1415: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1411: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1412: (
1413: l_api_name,
1414: G_PKG_NAME,
1415: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1416: x_msg_count,
1417: x_msg_data,
1418: '_PVT'
1419: );

Line 1421: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1417: x_msg_data,
1418: '_PVT'
1419: );
1420: WHEN OTHERS THEN
1421: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1422: (
1423: l_api_name,
1424: G_PKG_NAME,
1425: 'OTHERS',

Line 1445: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1441: x_rdsv_rec OUT NOCOPY rdsv_rec_type) IS
1442:
1443: l_api_version CONSTANT NUMBER := 1;
1444: l_api_name CONSTANT VARCHAR2(30) := 'V_insert_row';
1445: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1446: l_rdsv_rec rdsv_rec_type;
1447: l_def_rdsv_rec rdsv_rec_type;
1448: l_rds_rec rds_rec_type;
1449: lx_rds_rec rds_rec_type;

Line 1472: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1468: FUNCTION Set_Attributes (
1469: p_rdsv_rec IN rdsv_rec_type,
1470: x_rdsv_rec OUT NOCOPY rdsv_rec_type
1471: ) RETURN VARCHAR2 IS
1472: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1473: BEGIN
1474: x_rdsv_rec := p_rdsv_rec;
1475: x_rdsv_rec.OBJECT_VERSION_NUMBER := 1;
1476: RETURN(l_return_status);

Line 1479: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1475: x_rdsv_rec.OBJECT_VERSION_NUMBER := 1;
1476: RETURN(l_return_status);
1477: END Set_Attributes;
1478: BEGIN
1479: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1480: G_PKG_NAME,
1481: p_init_msg_list,
1482: l_api_version,
1483: p_api_version,

Line 1486: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1482: l_api_version,
1483: p_api_version,
1484: '_PVT',
1485: x_return_status);
1486: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1487: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1488: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1489: RAISE OKC_API.G_EXCEPTION_ERROR;
1490: END IF;

Line 1487: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1483: p_api_version,
1484: '_PVT',
1485: x_return_status);
1486: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1487: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1488: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1489: RAISE OKC_API.G_EXCEPTION_ERROR;
1490: END IF;
1491: l_rdsv_rec := null_out_defaults(p_rdsv_rec);

Line 1488: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1484: '_PVT',
1485: x_return_status);
1486: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1487: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1488: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1489: RAISE OKC_API.G_EXCEPTION_ERROR;
1490: END IF;
1491: l_rdsv_rec := null_out_defaults(p_rdsv_rec);
1492: --- Setting item attributes

Line 1489: RAISE OKC_API.G_EXCEPTION_ERROR;

1485: x_return_status);
1486: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1487: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1488: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1489: RAISE OKC_API.G_EXCEPTION_ERROR;
1490: END IF;
1491: l_rdsv_rec := null_out_defaults(p_rdsv_rec);
1492: --- Setting item attributes
1493: l_return_status := Set_Attributes(

Line 1497: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1493: l_return_status := Set_Attributes(
1494: l_rdsv_rec, -- IN
1495: l_def_rdsv_rec); -- OUT
1496: --- If any errors happen abort API
1497: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1498: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1499: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1500: RAISE OKC_API.G_EXCEPTION_ERROR;
1501: END IF;

Line 1498: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1494: l_rdsv_rec, -- IN
1495: l_def_rdsv_rec); -- OUT
1496: --- If any errors happen abort API
1497: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1498: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1499: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1500: RAISE OKC_API.G_EXCEPTION_ERROR;
1501: END IF;
1502: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);

Line 1499: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1495: l_def_rdsv_rec); -- OUT
1496: --- If any errors happen abort API
1497: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1498: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1499: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1500: RAISE OKC_API.G_EXCEPTION_ERROR;
1501: END IF;
1502: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);
1503: --- Validate all non-missing attributes (Item Level Validation)

Line 1500: RAISE OKC_API.G_EXCEPTION_ERROR;

1496: --- If any errors happen abort API
1497: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1498: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1499: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1500: RAISE OKC_API.G_EXCEPTION_ERROR;
1501: END IF;
1502: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);
1503: --- Validate all non-missing attributes (Item Level Validation)
1504: l_return_status := Validate_Attributes(l_def_rdsv_rec);

Line 1506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1502: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);
1503: --- Validate all non-missing attributes (Item Level Validation)
1504: l_return_status := Validate_Attributes(l_def_rdsv_rec);
1505: --- If any errors happen abort API
1506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1507: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1508: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1509: RAISE OKC_API.G_EXCEPTION_ERROR;
1510: END IF;

Line 1507: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1503: --- Validate all non-missing attributes (Item Level Validation)
1504: l_return_status := Validate_Attributes(l_def_rdsv_rec);
1505: --- If any errors happen abort API
1506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1507: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1508: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1509: RAISE OKC_API.G_EXCEPTION_ERROR;
1510: END IF;
1511: l_return_status := Validate_Record(l_def_rdsv_rec);

Line 1508: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1504: l_return_status := Validate_Attributes(l_def_rdsv_rec);
1505: --- If any errors happen abort API
1506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1507: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1508: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1509: RAISE OKC_API.G_EXCEPTION_ERROR;
1510: END IF;
1511: l_return_status := Validate_Record(l_def_rdsv_rec);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1509: RAISE OKC_API.G_EXCEPTION_ERROR;

1505: --- If any errors happen abort API
1506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1507: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1508: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1509: RAISE OKC_API.G_EXCEPTION_ERROR;
1510: END IF;
1511: l_return_status := Validate_Record(l_def_rdsv_rec);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

Line 1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1508: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1509: RAISE OKC_API.G_EXCEPTION_ERROR;
1510: END IF;
1511: l_return_status := Validate_Record(l_def_rdsv_rec);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;

Line 1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1509: RAISE OKC_API.G_EXCEPTION_ERROR;
1510: END IF;
1511: l_return_status := Validate_Record(l_def_rdsv_rec);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;
1517: --------------------------------------

Line 1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1510: END IF;
1511: l_return_status := Validate_Record(l_def_rdsv_rec);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;
1517: --------------------------------------
1518: -- Move VIEW record to "Child" records

Line 1515: RAISE OKC_API.G_EXCEPTION_ERROR;

1511: l_return_status := Validate_Record(l_def_rdsv_rec);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;
1517: --------------------------------------
1518: -- Move VIEW record to "Child" records
1519: --------------------------------------

Line 1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1528: x_msg_data,
1529: l_rds_rec,
1530: lx_rds_rec
1531: );
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: RAISE OKC_API.G_EXCEPTION_ERROR;
1536: END IF;

Line 1533: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1529: l_rds_rec,
1530: lx_rds_rec
1531: );
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: RAISE OKC_API.G_EXCEPTION_ERROR;
1536: END IF;
1537: migrate(lx_rds_rec, l_def_rdsv_rec);

Line 1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1530: lx_rds_rec
1531: );
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: RAISE OKC_API.G_EXCEPTION_ERROR;
1536: END IF;
1537: migrate(lx_rds_rec, l_def_rdsv_rec);
1538: -- Set OUT values

Line 1535: RAISE OKC_API.G_EXCEPTION_ERROR;

1531: );
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: RAISE OKC_API.G_EXCEPTION_ERROR;
1536: END IF;
1537: migrate(lx_rds_rec, l_def_rdsv_rec);
1538: -- Set OUT values
1539: x_rdsv_rec := l_def_rdsv_rec;

Line 1540: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1536: END IF;
1537: migrate(lx_rds_rec, l_def_rdsv_rec);
1538: -- Set OUT values
1539: x_rdsv_rec := l_def_rdsv_rec;
1540: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1541: EXCEPTION
1542: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1543: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1544: (

Line 1542: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1538: -- Set OUT values
1539: x_rdsv_rec := l_def_rdsv_rec;
1540: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1541: EXCEPTION
1542: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1543: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1544: (
1545: l_api_name,
1546: G_PKG_NAME,

Line 1543: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1539: x_rdsv_rec := l_def_rdsv_rec;
1540: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1541: EXCEPTION
1542: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1543: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1544: (
1545: l_api_name,
1546: G_PKG_NAME,
1547: 'OKC_API.G_RET_STS_ERROR',

Line 1547: 'OKC_API.G_RET_STS_ERROR',

1543: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1544: (
1545: l_api_name,
1546: G_PKG_NAME,
1547: 'OKC_API.G_RET_STS_ERROR',
1548: x_msg_count,
1549: x_msg_data,
1550: '_PVT'
1551: );

Line 1552: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1548: x_msg_count,
1549: x_msg_data,
1550: '_PVT'
1551: );
1552: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1553: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1554: (
1555: l_api_name,
1556: G_PKG_NAME,

Line 1553: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1549: x_msg_data,
1550: '_PVT'
1551: );
1552: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1553: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1554: (
1555: l_api_name,
1556: G_PKG_NAME,
1557: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1557: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1553: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1554: (
1555: l_api_name,
1556: G_PKG_NAME,
1557: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1558: x_msg_count,
1559: x_msg_data,
1560: '_PVT'
1561: );

Line 1563: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1559: x_msg_data,
1560: '_PVT'
1561: );
1562: WHEN OTHERS THEN
1563: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1564: (
1565: l_api_name,
1566: G_PKG_NAME,
1567: 'OTHERS',

Line 1587: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1583: x_rdsv_tbl OUT NOCOPY rdsv_tbl_type) IS
1584:
1585: l_api_version CONSTANT NUMBER := 1;
1586: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
1587: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1588: i NUMBER := 0;
1589: BEGIN
1590: OKC_API.init_msg_list(p_init_msg_list);
1591: -- Make sure PL/SQL table has records in it before passing

Line 1590: OKC_API.init_msg_list(p_init_msg_list);

1586: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
1587: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1588: i NUMBER := 0;
1589: BEGIN
1590: OKC_API.init_msg_list(p_init_msg_list);
1591: -- Make sure PL/SQL table has records in it before passing
1592: IF (p_rdsv_tbl.COUNT > 0) THEN
1593: i := p_rdsv_tbl.FIRST;
1594: LOOP

Line 1597: p_init_msg_list => OKC_API.G_FALSE,

1593: i := p_rdsv_tbl.FIRST;
1594: LOOP
1595: insert_row (
1596: p_api_version => p_api_version,
1597: p_init_msg_list => OKC_API.G_FALSE,
1598: x_return_status => x_return_status,
1599: x_msg_count => x_msg_count,
1600: x_msg_data => x_msg_data,
1601: p_rdsv_rec => p_rdsv_tbl(i),

Line 1608: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1604: i := p_rdsv_tbl.NEXT(i);
1605: END LOOP;
1606: END IF;
1607: EXCEPTION
1608: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1609: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1610: (
1611: l_api_name,
1612: G_PKG_NAME,

Line 1609: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1605: END LOOP;
1606: END IF;
1607: EXCEPTION
1608: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1609: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1610: (
1611: l_api_name,
1612: G_PKG_NAME,
1613: 'OKC_API.G_RET_STS_ERROR',

Line 1613: 'OKC_API.G_RET_STS_ERROR',

1609: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1610: (
1611: l_api_name,
1612: G_PKG_NAME,
1613: 'OKC_API.G_RET_STS_ERROR',
1614: x_msg_count,
1615: x_msg_data,
1616: '_PVT'
1617: );

Line 1618: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1614: x_msg_count,
1615: x_msg_data,
1616: '_PVT'
1617: );
1618: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1619: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1620: (
1621: l_api_name,
1622: G_PKG_NAME,

Line 1619: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1615: x_msg_data,
1616: '_PVT'
1617: );
1618: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1619: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1620: (
1621: l_api_name,
1622: G_PKG_NAME,
1623: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1623: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1619: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1620: (
1621: l_api_name,
1622: G_PKG_NAME,
1623: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1624: x_msg_count,
1625: x_msg_data,
1626: '_PVT'
1627: );

Line 1629: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1625: x_msg_data,
1626: '_PVT'
1627: );
1628: WHEN OTHERS THEN
1629: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1630: (
1631: l_api_name,
1632: G_PKG_NAME,
1633: 'OTHERS',

Line 1676: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1672: AND OBJECT_ID_NUMBER = p_rds_rec.object_id_number
1673: AND START_DATE = p_rds_rec.start_date;
1674: l_api_version CONSTANT NUMBER := 1;
1675: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_lock_row';
1676: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1677: l_object_version_number OKC_RULE_DEF_SOURCES.OBJECT_VERSION_NUMBER%TYPE;
1678: lc_object_version_number OKC_RULE_DEF_SOURCES.OBJECT_VERSION_NUMBER%TYPE;
1679: l_row_notfound BOOLEAN := FALSE;
1680: lc_row_notfound BOOLEAN := FALSE;

Line 1682: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1678: lc_object_version_number OKC_RULE_DEF_SOURCES.OBJECT_VERSION_NUMBER%TYPE;
1679: l_row_notfound BOOLEAN := FALSE;
1680: lc_row_notfound BOOLEAN := FALSE;
1681: BEGIN
1682: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1683: p_init_msg_list,
1684: '_PVT',
1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1682: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1683: p_init_msg_list,
1684: '_PVT',
1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;

Line 1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1683: p_init_msg_list,
1684: '_PVT',
1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;
1691: BEGIN

Line 1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1684: '_PVT',
1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;
1691: BEGIN
1692: OPEN lock_csr(p_rds_rec);

Line 1689: RAISE OKC_API.G_EXCEPTION_ERROR;

1685: x_return_status);
1686: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1687: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1688: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1689: RAISE OKC_API.G_EXCEPTION_ERROR;
1690: END IF;
1691: BEGIN
1692: OPEN lock_csr(p_rds_rec);
1693: FETCH lock_csr INTO l_object_version_number;

Line 1701: OKC_API.set_message(G_FND_APP,G_FORM_UNABLE_TO_RESERVE_REC);

1697: WHEN E_Resource_Busy THEN
1698: IF (lock_csr%ISOPEN) THEN
1699: CLOSE lock_csr;
1700: END IF;
1701: OKC_API.set_message(G_FND_APP,G_FORM_UNABLE_TO_RESERVE_REC);
1702: RAISE APP_EXCEPTIONS.RECORD_LOCK_EXCEPTION;
1703: END;
1704:
1705: IF ( l_row_notfound ) THEN

Line 1712: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);

1708: lc_row_notfound := lchk_csr%NOTFOUND;
1709: CLOSE lchk_csr;
1710: END IF;
1711: IF (lc_row_notfound) THEN
1712: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1713: RAISE OKC_API.G_EXCEPTION_ERROR;
1714: ELSIF lc_object_version_number > p_rds_rec.object_version_number THEN
1715: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1716: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1713: RAISE OKC_API.G_EXCEPTION_ERROR;

1709: CLOSE lchk_csr;
1710: END IF;
1711: IF (lc_row_notfound) THEN
1712: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1713: RAISE OKC_API.G_EXCEPTION_ERROR;
1714: ELSIF lc_object_version_number > p_rds_rec.object_version_number THEN
1715: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1716: RAISE OKC_API.G_EXCEPTION_ERROR;
1717: ELSIF lc_object_version_number <> p_rds_rec.object_version_number THEN

Line 1715: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);

1711: IF (lc_row_notfound) THEN
1712: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1713: RAISE OKC_API.G_EXCEPTION_ERROR;
1714: ELSIF lc_object_version_number > p_rds_rec.object_version_number THEN
1715: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1716: RAISE OKC_API.G_EXCEPTION_ERROR;
1717: ELSIF lc_object_version_number <> p_rds_rec.object_version_number THEN
1718: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1719: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1716: RAISE OKC_API.G_EXCEPTION_ERROR;

1712: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1713: RAISE OKC_API.G_EXCEPTION_ERROR;
1714: ELSIF lc_object_version_number > p_rds_rec.object_version_number THEN
1715: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1716: RAISE OKC_API.G_EXCEPTION_ERROR;
1717: ELSIF lc_object_version_number <> p_rds_rec.object_version_number THEN
1718: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: ELSIF lc_object_version_number = -1 THEN

Line 1718: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);

1714: ELSIF lc_object_version_number > p_rds_rec.object_version_number THEN
1715: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1716: RAISE OKC_API.G_EXCEPTION_ERROR;
1717: ELSIF lc_object_version_number <> p_rds_rec.object_version_number THEN
1718: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: ELSIF lc_object_version_number = -1 THEN
1721: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1722: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1719: RAISE OKC_API.G_EXCEPTION_ERROR;

1715: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1716: RAISE OKC_API.G_EXCEPTION_ERROR;
1717: ELSIF lc_object_version_number <> p_rds_rec.object_version_number THEN
1718: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: ELSIF lc_object_version_number = -1 THEN
1721: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1722: RAISE OKC_API.G_EXCEPTION_ERROR;
1723: END IF;

Line 1721: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);

1717: ELSIF lc_object_version_number <> p_rds_rec.object_version_number THEN
1718: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: ELSIF lc_object_version_number = -1 THEN
1721: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1722: RAISE OKC_API.G_EXCEPTION_ERROR;
1723: END IF;
1724: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1725: EXCEPTION

Line 1722: RAISE OKC_API.G_EXCEPTION_ERROR;

1718: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1719: RAISE OKC_API.G_EXCEPTION_ERROR;
1720: ELSIF lc_object_version_number = -1 THEN
1721: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1722: RAISE OKC_API.G_EXCEPTION_ERROR;
1723: END IF;
1724: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1725: EXCEPTION
1726: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 1724: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1720: ELSIF lc_object_version_number = -1 THEN
1721: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1722: RAISE OKC_API.G_EXCEPTION_ERROR;
1723: END IF;
1724: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1725: EXCEPTION
1726: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1727: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1728: (

Line 1726: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1722: RAISE OKC_API.G_EXCEPTION_ERROR;
1723: END IF;
1724: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1725: EXCEPTION
1726: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1727: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1728: (
1729: l_api_name,
1730: G_PKG_NAME,

Line 1727: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1723: END IF;
1724: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1725: EXCEPTION
1726: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1727: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1728: (
1729: l_api_name,
1730: G_PKG_NAME,
1731: 'OKC_API.G_RET_STS_ERROR',

Line 1731: 'OKC_API.G_RET_STS_ERROR',

1727: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1728: (
1729: l_api_name,
1730: G_PKG_NAME,
1731: 'OKC_API.G_RET_STS_ERROR',
1732: x_msg_count,
1733: x_msg_data,
1734: '_PVT'
1735: );

Line 1736: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1732: x_msg_count,
1733: x_msg_data,
1734: '_PVT'
1735: );
1736: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1738: (
1739: l_api_name,
1740: G_PKG_NAME,

Line 1737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1733: x_msg_data,
1734: '_PVT'
1735: );
1736: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1738: (
1739: l_api_name,
1740: G_PKG_NAME,
1741: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1741: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1737: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1738: (
1739: l_api_name,
1740: G_PKG_NAME,
1741: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1742: x_msg_count,
1743: x_msg_data,
1744: '_PVT'
1745: );

Line 1747: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1743: x_msg_data,
1744: '_PVT'
1745: );
1746: WHEN OTHERS THEN
1747: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1748: (
1749: l_api_name,
1750: G_PKG_NAME,
1751: 'OTHERS',

Line 1770: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1766: p_rdsv_rec IN rdsv_rec_type) IS
1767:
1768: l_api_version CONSTANT NUMBER := 1;
1769: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
1770: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1771: l_rds_rec rds_rec_type;
1772: BEGIN
1773: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1774: G_PKG_NAME,

Line 1773: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1769: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
1770: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1771: l_rds_rec rds_rec_type;
1772: BEGIN
1773: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1774: G_PKG_NAME,
1775: p_init_msg_list,
1776: l_api_version,
1777: p_api_version,

Line 1780: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1776: l_api_version,
1777: p_api_version,
1778: '_PVT',
1779: x_return_status);
1780: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1781: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1782: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1783: RAISE OKC_API.G_EXCEPTION_ERROR;
1784: END IF;

Line 1781: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1777: p_api_version,
1778: '_PVT',
1779: x_return_status);
1780: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1781: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1782: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1783: RAISE OKC_API.G_EXCEPTION_ERROR;
1784: END IF;
1785: --------------------------------------

Line 1782: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1778: '_PVT',
1779: x_return_status);
1780: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1781: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1782: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1783: RAISE OKC_API.G_EXCEPTION_ERROR;
1784: END IF;
1785: --------------------------------------
1786: -- Move VIEW record to "Child" records

Line 1783: RAISE OKC_API.G_EXCEPTION_ERROR;

1779: x_return_status);
1780: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1781: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1782: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1783: RAISE OKC_API.G_EXCEPTION_ERROR;
1784: END IF;
1785: --------------------------------------
1786: -- Move VIEW record to "Child" records
1787: --------------------------------------

Line 1799: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1795: x_msg_count,
1796: x_msg_data,
1797: l_rds_rec
1798: );
1799: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1801: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1802: RAISE OKC_API.G_EXCEPTION_ERROR;
1803: END IF;

Line 1800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1796: x_msg_data,
1797: l_rds_rec
1798: );
1799: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1801: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1802: RAISE OKC_API.G_EXCEPTION_ERROR;
1803: END IF;
1804: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1801: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1797: l_rds_rec
1798: );
1799: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1801: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1802: RAISE OKC_API.G_EXCEPTION_ERROR;
1803: END IF;
1804: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1805: EXCEPTION

Line 1802: RAISE OKC_API.G_EXCEPTION_ERROR;

1798: );
1799: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1801: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1802: RAISE OKC_API.G_EXCEPTION_ERROR;
1803: END IF;
1804: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1805: EXCEPTION
1806: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 1804: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1801: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1802: RAISE OKC_API.G_EXCEPTION_ERROR;
1803: END IF;
1804: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1805: EXCEPTION
1806: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1807: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1808: (

Line 1806: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1802: RAISE OKC_API.G_EXCEPTION_ERROR;
1803: END IF;
1804: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1805: EXCEPTION
1806: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1807: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1808: (
1809: l_api_name,
1810: G_PKG_NAME,

Line 1807: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1803: END IF;
1804: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1805: EXCEPTION
1806: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1807: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1808: (
1809: l_api_name,
1810: G_PKG_NAME,
1811: 'OKC_API.G_RET_STS_ERROR',

Line 1811: 'OKC_API.G_RET_STS_ERROR',

1807: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1808: (
1809: l_api_name,
1810: G_PKG_NAME,
1811: 'OKC_API.G_RET_STS_ERROR',
1812: x_msg_count,
1813: x_msg_data,
1814: '_PVT'
1815: );

Line 1816: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1812: x_msg_count,
1813: x_msg_data,
1814: '_PVT'
1815: );
1816: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1817: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1818: (
1819: l_api_name,
1820: G_PKG_NAME,

Line 1817: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1813: x_msg_data,
1814: '_PVT'
1815: );
1816: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1817: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1818: (
1819: l_api_name,
1820: G_PKG_NAME,
1821: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1821: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1817: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1818: (
1819: l_api_name,
1820: G_PKG_NAME,
1821: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1822: x_msg_count,
1823: x_msg_data,
1824: '_PVT'
1825: );

Line 1827: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1823: x_msg_data,
1824: '_PVT'
1825: );
1826: WHEN OTHERS THEN
1827: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1828: (
1829: l_api_name,
1830: G_PKG_NAME,
1831: 'OTHERS',

Line 1850: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1846: p_rdsv_tbl IN rdsv_tbl_type) IS
1847:
1848: l_api_version CONSTANT NUMBER := 1;
1849: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
1850: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1851: i NUMBER := 0;
1852: BEGIN
1853: OKC_API.init_msg_list(p_init_msg_list);
1854: -- Make sure PL/SQL table has records in it before passing

Line 1853: OKC_API.init_msg_list(p_init_msg_list);

1849: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
1850: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1851: i NUMBER := 0;
1852: BEGIN
1853: OKC_API.init_msg_list(p_init_msg_list);
1854: -- Make sure PL/SQL table has records in it before passing
1855: IF (p_rdsv_tbl.COUNT > 0) THEN
1856: i := p_rdsv_tbl.FIRST;
1857: LOOP

Line 1860: p_init_msg_list => OKC_API.G_FALSE,

1856: i := p_rdsv_tbl.FIRST;
1857: LOOP
1858: lock_row (
1859: p_api_version => p_api_version,
1860: p_init_msg_list => OKC_API.G_FALSE,
1861: x_return_status => x_return_status,
1862: x_msg_count => x_msg_count,
1863: x_msg_data => x_msg_data,
1864: p_rdsv_rec => p_rdsv_tbl(i));

Line 1870: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1866: i := p_rdsv_tbl.NEXT(i);
1867: END LOOP;
1868: END IF;
1869: EXCEPTION
1870: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1871: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1872: (
1873: l_api_name,
1874: G_PKG_NAME,

Line 1871: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1867: END LOOP;
1868: END IF;
1869: EXCEPTION
1870: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1871: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1872: (
1873: l_api_name,
1874: G_PKG_NAME,
1875: 'OKC_API.G_RET_STS_ERROR',

Line 1875: 'OKC_API.G_RET_STS_ERROR',

1871: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1872: (
1873: l_api_name,
1874: G_PKG_NAME,
1875: 'OKC_API.G_RET_STS_ERROR',
1876: x_msg_count,
1877: x_msg_data,
1878: '_PVT'
1879: );

Line 1880: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1876: x_msg_count,
1877: x_msg_data,
1878: '_PVT'
1879: );
1880: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1881: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1882: (
1883: l_api_name,
1884: G_PKG_NAME,

Line 1881: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1877: x_msg_data,
1878: '_PVT'
1879: );
1880: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1881: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1882: (
1883: l_api_name,
1884: G_PKG_NAME,
1885: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1885: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1881: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1882: (
1883: l_api_name,
1884: G_PKG_NAME,
1885: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1886: x_msg_count,
1887: x_msg_data,
1888: '_PVT'
1889: );

Line 1891: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1887: x_msg_data,
1888: '_PVT'
1889: );
1890: WHEN OTHERS THEN
1891: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1892: (
1893: l_api_name,
1894: G_PKG_NAME,
1895: 'OTHERS',

Line 1918: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1914: x_rds_rec OUT NOCOPY rds_rec_type) IS
1915:
1916: l_api_version CONSTANT NUMBER := 1;
1917: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_update_row';
1918: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1919: l_rds_rec rds_rec_type := p_rds_rec;
1920: l_def_rds_rec rds_rec_type;
1921: l_row_notfound BOOLEAN := TRUE;
1922: ----------------------------------

Line 1931: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1927: x_rds_rec OUT NOCOPY rds_rec_type
1928: ) RETURN VARCHAR2 IS
1929: l_rds_rec rds_rec_type;
1930: l_row_notfound BOOLEAN := TRUE;
1931: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1932: BEGIN
1933: x_rds_rec := p_rds_rec;
1934: -- Get current database values
1935: l_rds_rec := get_rec(p_rds_rec, l_row_notfound);

Line 1937: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1933: x_rds_rec := p_rds_rec;
1934: -- Get current database values
1935: l_rds_rec := get_rec(p_rds_rec, l_row_notfound);
1936: IF (l_row_notfound) THEN
1937: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1938: END IF;
1939: IF (x_rds_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)
1940: THEN
1941: x_rds_rec.rgr_rgd_code := l_rds_rec.rgr_rgd_code;

Line 1939: IF (x_rds_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)

1935: l_rds_rec := get_rec(p_rds_rec, l_row_notfound);
1936: IF (l_row_notfound) THEN
1937: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1938: END IF;
1939: IF (x_rds_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)
1940: THEN
1941: x_rds_rec.rgr_rgd_code := l_rds_rec.rgr_rgd_code;
1942: END IF;
1943: IF (x_rds_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)

Line 1943: IF (x_rds_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)

1939: IF (x_rds_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)
1940: THEN
1941: x_rds_rec.rgr_rgd_code := l_rds_rec.rgr_rgd_code;
1942: END IF;
1943: IF (x_rds_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)
1944: THEN
1945: x_rds_rec.rgr_rdf_code := l_rds_rec.rgr_rdf_code;
1946: END IF;
1947: IF (x_rds_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

Line 1947: IF (x_rds_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

1943: IF (x_rds_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)
1944: THEN
1945: x_rds_rec.rgr_rdf_code := l_rds_rec.rgr_rdf_code;
1946: END IF;
1947: IF (x_rds_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
1948: THEN
1949: x_rds_rec.buy_or_sell := l_rds_rec.buy_or_sell;
1950: END IF;
1951: IF (x_rds_rec.access_level = OKC_API.G_MISS_CHAR)

Line 1951: IF (x_rds_rec.access_level = OKC_API.G_MISS_CHAR)

1947: IF (x_rds_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
1948: THEN
1949: x_rds_rec.buy_or_sell := l_rds_rec.buy_or_sell;
1950: END IF;
1951: IF (x_rds_rec.access_level = OKC_API.G_MISS_CHAR)
1952: THEN
1953: x_rds_rec.access_level := l_rds_rec.access_level;
1954: END IF;
1955: IF (x_rds_rec.start_date = OKC_API.G_MISS_DATE)

Line 1955: IF (x_rds_rec.start_date = OKC_API.G_MISS_DATE)

1951: IF (x_rds_rec.access_level = OKC_API.G_MISS_CHAR)
1952: THEN
1953: x_rds_rec.access_level := l_rds_rec.access_level;
1954: END IF;
1955: IF (x_rds_rec.start_date = OKC_API.G_MISS_DATE)
1956: THEN
1957: x_rds_rec.start_date := l_rds_rec.start_date;
1958: END IF;
1959: IF (x_rds_rec.end_date = OKC_API.G_MISS_DATE)

Line 1959: IF (x_rds_rec.end_date = OKC_API.G_MISS_DATE)

1955: IF (x_rds_rec.start_date = OKC_API.G_MISS_DATE)
1956: THEN
1957: x_rds_rec.start_date := l_rds_rec.start_date;
1958: END IF;
1959: IF (x_rds_rec.end_date = OKC_API.G_MISS_DATE)
1960: THEN
1961: x_rds_rec.end_date := l_rds_rec.end_date;
1962: END IF;
1963: IF (x_rds_rec.jtot_object_code = OKC_API.G_MISS_CHAR)

Line 1963: IF (x_rds_rec.jtot_object_code = OKC_API.G_MISS_CHAR)

1959: IF (x_rds_rec.end_date = OKC_API.G_MISS_DATE)
1960: THEN
1961: x_rds_rec.end_date := l_rds_rec.end_date;
1962: END IF;
1963: IF (x_rds_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
1964: THEN
1965: x_rds_rec.jtot_object_code := l_rds_rec.jtot_object_code;
1966: END IF;
1967: IF (x_rds_rec.object_id_number = OKC_API.G_MISS_NUM)

Line 1967: IF (x_rds_rec.object_id_number = OKC_API.G_MISS_NUM)

1963: IF (x_rds_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
1964: THEN
1965: x_rds_rec.jtot_object_code := l_rds_rec.jtot_object_code;
1966: END IF;
1967: IF (x_rds_rec.object_id_number = OKC_API.G_MISS_NUM)
1968: THEN
1969: x_rds_rec.object_id_number := l_rds_rec.object_id_number;
1970: END IF;
1971: IF (x_rds_rec.object_version_number = OKC_API.G_MISS_NUM)

Line 1971: IF (x_rds_rec.object_version_number = OKC_API.G_MISS_NUM)

1967: IF (x_rds_rec.object_id_number = OKC_API.G_MISS_NUM)
1968: THEN
1969: x_rds_rec.object_id_number := l_rds_rec.object_id_number;
1970: END IF;
1971: IF (x_rds_rec.object_version_number = OKC_API.G_MISS_NUM)
1972: THEN
1973: x_rds_rec.object_version_number := l_rds_rec.object_version_number;
1974: END IF;
1975: IF (x_rds_rec.created_by = OKC_API.G_MISS_NUM)

Line 1975: IF (x_rds_rec.created_by = OKC_API.G_MISS_NUM)

1971: IF (x_rds_rec.object_version_number = OKC_API.G_MISS_NUM)
1972: THEN
1973: x_rds_rec.object_version_number := l_rds_rec.object_version_number;
1974: END IF;
1975: IF (x_rds_rec.created_by = OKC_API.G_MISS_NUM)
1976: THEN
1977: x_rds_rec.created_by := l_rds_rec.created_by;
1978: END IF;
1979: IF (x_rds_rec.creation_date = OKC_API.G_MISS_DATE)

Line 1979: IF (x_rds_rec.creation_date = OKC_API.G_MISS_DATE)

1975: IF (x_rds_rec.created_by = OKC_API.G_MISS_NUM)
1976: THEN
1977: x_rds_rec.created_by := l_rds_rec.created_by;
1978: END IF;
1979: IF (x_rds_rec.creation_date = OKC_API.G_MISS_DATE)
1980: THEN
1981: x_rds_rec.creation_date := l_rds_rec.creation_date;
1982: END IF;
1983: IF (x_rds_rec.last_updated_by = OKC_API.G_MISS_NUM)

Line 1983: IF (x_rds_rec.last_updated_by = OKC_API.G_MISS_NUM)

1979: IF (x_rds_rec.creation_date = OKC_API.G_MISS_DATE)
1980: THEN
1981: x_rds_rec.creation_date := l_rds_rec.creation_date;
1982: END IF;
1983: IF (x_rds_rec.last_updated_by = OKC_API.G_MISS_NUM)
1984: THEN
1985: x_rds_rec.last_updated_by := l_rds_rec.last_updated_by;
1986: END IF;
1987: IF (x_rds_rec.last_update_date = OKC_API.G_MISS_DATE)

Line 1987: IF (x_rds_rec.last_update_date = OKC_API.G_MISS_DATE)

1983: IF (x_rds_rec.last_updated_by = OKC_API.G_MISS_NUM)
1984: THEN
1985: x_rds_rec.last_updated_by := l_rds_rec.last_updated_by;
1986: END IF;
1987: IF (x_rds_rec.last_update_date = OKC_API.G_MISS_DATE)
1988: THEN
1989: x_rds_rec.last_update_date := l_rds_rec.last_update_date;
1990: END IF;
1991: IF (x_rds_rec.last_update_login = OKC_API.G_MISS_NUM)

Line 1991: IF (x_rds_rec.last_update_login = OKC_API.G_MISS_NUM)

1987: IF (x_rds_rec.last_update_date = OKC_API.G_MISS_DATE)
1988: THEN
1989: x_rds_rec.last_update_date := l_rds_rec.last_update_date;
1990: END IF;
1991: IF (x_rds_rec.last_update_login = OKC_API.G_MISS_NUM)
1992: THEN
1993: x_rds_rec.last_update_login := l_rds_rec.last_update_login;
1994: END IF;
1995: RETURN(l_return_status);

Line 2004: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2000: FUNCTION Set_Attributes (
2001: p_rds_rec IN rds_rec_type,
2002: x_rds_rec OUT NOCOPY rds_rec_type
2003: ) RETURN VARCHAR2 IS
2004: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2005: BEGIN
2006: x_rds_rec := p_rds_rec;
2007: RETURN(l_return_status);
2008: END Set_Attributes;

Line 2010: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2006: x_rds_rec := p_rds_rec;
2007: RETURN(l_return_status);
2008: END Set_Attributes;
2009: BEGIN
2010: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2011: p_init_msg_list,
2012: '_PVT',
2013: x_return_status);
2014: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2014: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2010: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2011: p_init_msg_list,
2012: '_PVT',
2013: x_return_status);
2014: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2015: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2016: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2017: RAISE OKC_API.G_EXCEPTION_ERROR;
2018: END IF;

Line 2015: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2011: p_init_msg_list,
2012: '_PVT',
2013: x_return_status);
2014: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2015: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2016: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2017: RAISE OKC_API.G_EXCEPTION_ERROR;
2018: END IF;
2019: --- Setting item attributes

Line 2016: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2012: '_PVT',
2013: x_return_status);
2014: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2015: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2016: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2017: RAISE OKC_API.G_EXCEPTION_ERROR;
2018: END IF;
2019: --- Setting item attributes
2020: l_return_status := Set_Attributes(

Line 2017: RAISE OKC_API.G_EXCEPTION_ERROR;

2013: x_return_status);
2014: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2015: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2016: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2017: RAISE OKC_API.G_EXCEPTION_ERROR;
2018: END IF;
2019: --- Setting item attributes
2020: l_return_status := Set_Attributes(
2021: p_rds_rec, -- IN

Line 2024: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2020: l_return_status := Set_Attributes(
2021: p_rds_rec, -- IN
2022: l_rds_rec); -- OUT
2023: --- If any errors happen abort API
2024: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2025: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2026: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2027: RAISE OKC_API.G_EXCEPTION_ERROR;
2028: END IF;

Line 2025: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2021: p_rds_rec, -- IN
2022: l_rds_rec); -- OUT
2023: --- If any errors happen abort API
2024: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2025: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2026: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2027: RAISE OKC_API.G_EXCEPTION_ERROR;
2028: END IF;
2029: l_return_status := populate_new_record(l_rds_rec, l_def_rds_rec);

Line 2026: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2022: l_rds_rec); -- OUT
2023: --- If any errors happen abort API
2024: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2025: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2026: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2027: RAISE OKC_API.G_EXCEPTION_ERROR;
2028: END IF;
2029: l_return_status := populate_new_record(l_rds_rec, l_def_rds_rec);
2030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2027: RAISE OKC_API.G_EXCEPTION_ERROR;

2023: --- If any errors happen abort API
2024: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2025: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2026: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2027: RAISE OKC_API.G_EXCEPTION_ERROR;
2028: END IF;
2029: l_return_status := populate_new_record(l_rds_rec, l_def_rds_rec);
2030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

Line 2030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2026: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2027: RAISE OKC_API.G_EXCEPTION_ERROR;
2028: END IF;
2029: l_return_status := populate_new_record(l_rds_rec, l_def_rds_rec);
2030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2033: RAISE OKC_API.G_EXCEPTION_ERROR;
2034: END IF;

Line 2031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2027: RAISE OKC_API.G_EXCEPTION_ERROR;
2028: END IF;
2029: l_return_status := populate_new_record(l_rds_rec, l_def_rds_rec);
2030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2033: RAISE OKC_API.G_EXCEPTION_ERROR;
2034: END IF;
2035: UPDATE OKC_RULE_DEF_SOURCES

Line 2032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2028: END IF;
2029: l_return_status := populate_new_record(l_rds_rec, l_def_rds_rec);
2030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2033: RAISE OKC_API.G_EXCEPTION_ERROR;
2034: END IF;
2035: UPDATE OKC_RULE_DEF_SOURCES
2036: SET END_DATE = l_def_rds_rec.end_date,

Line 2033: RAISE OKC_API.G_EXCEPTION_ERROR;

2029: l_return_status := populate_new_record(l_rds_rec, l_def_rds_rec);
2030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2033: RAISE OKC_API.G_EXCEPTION_ERROR;
2034: END IF;
2035: UPDATE OKC_RULE_DEF_SOURCES
2036: SET END_DATE = l_def_rds_rec.end_date,
2037: JTOT_OBJECT_CODE = l_def_rds_rec.jtot_object_code,

Line 2050: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2046: AND RGR_RDF_CODE = l_def_rds_rec.rgr_rdf_code
2047: AND TRUNC(START_DATE) = TRUNC(l_def_rds_rec.start_date)
2048: AND OBJECT_ID_NUMBER = l_def_rds_rec.object_id_number;
2049: x_rds_rec := l_def_rds_rec;
2050: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2051: EXCEPTION
2052: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2053: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2054: (

Line 2052: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2048: AND OBJECT_ID_NUMBER = l_def_rds_rec.object_id_number;
2049: x_rds_rec := l_def_rds_rec;
2050: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2051: EXCEPTION
2052: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2053: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2054: (
2055: l_api_name,
2056: G_PKG_NAME,

Line 2053: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2049: x_rds_rec := l_def_rds_rec;
2050: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2051: EXCEPTION
2052: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2053: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2054: (
2055: l_api_name,
2056: G_PKG_NAME,
2057: 'OKC_API.G_RET_STS_ERROR',

Line 2057: 'OKC_API.G_RET_STS_ERROR',

2053: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2054: (
2055: l_api_name,
2056: G_PKG_NAME,
2057: 'OKC_API.G_RET_STS_ERROR',
2058: x_msg_count,
2059: x_msg_data,
2060: '_PVT'
2061: );

Line 2062: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2058: x_msg_count,
2059: x_msg_data,
2060: '_PVT'
2061: );
2062: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2063: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2064: (
2065: l_api_name,
2066: G_PKG_NAME,

Line 2063: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2059: x_msg_data,
2060: '_PVT'
2061: );
2062: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2063: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2064: (
2065: l_api_name,
2066: G_PKG_NAME,
2067: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2067: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2063: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2064: (
2065: l_api_name,
2066: G_PKG_NAME,
2067: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2068: x_msg_count,
2069: x_msg_data,
2070: '_PVT'
2071: );

Line 2073: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2069: x_msg_data,
2070: '_PVT'
2071: );
2072: WHEN OTHERS THEN
2073: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2074: (
2075: l_api_name,
2076: G_PKG_NAME,
2077: 'OTHERS',

Line 2097: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2093: x_rdsv_rec OUT NOCOPY rdsv_rec_type) IS
2094:
2095: l_api_version CONSTANT NUMBER := 1;
2096: l_api_name CONSTANT VARCHAR2(30) := 'V_update_row';
2097: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2098: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
2099: l_def_rdsv_rec rdsv_rec_type;
2100: l_rds_rec rds_rec_type;
2101: lx_rds_rec rds_rec_type;

Line 2124: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2120: x_rdsv_rec OUT NOCOPY rdsv_rec_type
2121: ) RETURN VARCHAR2 IS
2122: l_rdsv_rec rdsv_rec_type;
2123: l_row_notfound BOOLEAN := TRUE;
2124: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2125: BEGIN
2126: x_rdsv_rec := p_rdsv_rec;
2127: -- Get current database values
2128: l_rdsv_rec := get_rec(p_rdsv_rec, l_row_notfound);

Line 2130: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2126: x_rdsv_rec := p_rdsv_rec;
2127: -- Get current database values
2128: l_rdsv_rec := get_rec(p_rdsv_rec, l_row_notfound);
2129: IF (l_row_notfound) THEN
2130: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2131: END IF;
2132: IF (x_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
2133: THEN
2134: x_rdsv_rec.jtot_object_code := l_rdsv_rec.jtot_object_code;

Line 2132: IF (x_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)

2128: l_rdsv_rec := get_rec(p_rdsv_rec, l_row_notfound);
2129: IF (l_row_notfound) THEN
2130: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2131: END IF;
2132: IF (x_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
2133: THEN
2134: x_rdsv_rec.jtot_object_code := l_rdsv_rec.jtot_object_code;
2135: END IF;
2136: IF (x_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)

Line 2136: IF (x_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)

2132: IF (x_rdsv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
2133: THEN
2134: x_rdsv_rec.jtot_object_code := l_rdsv_rec.jtot_object_code;
2135: END IF;
2136: IF (x_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)
2137: THEN
2138: x_rdsv_rec.rgr_rgd_code := l_rdsv_rec.rgr_rgd_code;
2139: END IF;
2140: IF (x_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)

Line 2140: IF (x_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)

2136: IF (x_rdsv_rec.rgr_rgd_code = OKC_API.G_MISS_CHAR)
2137: THEN
2138: x_rdsv_rec.rgr_rgd_code := l_rdsv_rec.rgr_rgd_code;
2139: END IF;
2140: IF (x_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)
2141: THEN
2142: x_rdsv_rec.rgr_rdf_code := l_rdsv_rec.rgr_rdf_code;
2143: END IF;
2144: IF (x_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

Line 2144: IF (x_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

2140: IF (x_rdsv_rec.rgr_rdf_code = OKC_API.G_MISS_CHAR)
2141: THEN
2142: x_rdsv_rec.rgr_rdf_code := l_rdsv_rec.rgr_rdf_code;
2143: END IF;
2144: IF (x_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
2145: THEN
2146: x_rdsv_rec.buy_or_sell := l_rdsv_rec.buy_or_sell;
2147: END IF;
2148: IF (x_rdsv_rec.access_level = OKC_API.G_MISS_CHAR)

Line 2148: IF (x_rdsv_rec.access_level = OKC_API.G_MISS_CHAR)

2144: IF (x_rdsv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
2145: THEN
2146: x_rdsv_rec.buy_or_sell := l_rdsv_rec.buy_or_sell;
2147: END IF;
2148: IF (x_rdsv_rec.access_level = OKC_API.G_MISS_CHAR)
2149: THEN
2150: x_rdsv_rec.access_level := l_rdsv_rec.access_level;
2151: END IF;
2152: IF (x_rdsv_rec.start_date = OKC_API.G_MISS_DATE)

Line 2152: IF (x_rdsv_rec.start_date = OKC_API.G_MISS_DATE)

2148: IF (x_rdsv_rec.access_level = OKC_API.G_MISS_CHAR)
2149: THEN
2150: x_rdsv_rec.access_level := l_rdsv_rec.access_level;
2151: END IF;
2152: IF (x_rdsv_rec.start_date = OKC_API.G_MISS_DATE)
2153: THEN
2154: x_rdsv_rec.start_date := l_rdsv_rec.start_date;
2155: END IF;
2156: IF (x_rdsv_rec.end_date = OKC_API.G_MISS_DATE)

Line 2156: IF (x_rdsv_rec.end_date = OKC_API.G_MISS_DATE)

2152: IF (x_rdsv_rec.start_date = OKC_API.G_MISS_DATE)
2153: THEN
2154: x_rdsv_rec.start_date := l_rdsv_rec.start_date;
2155: END IF;
2156: IF (x_rdsv_rec.end_date = OKC_API.G_MISS_DATE)
2157: THEN
2158: x_rdsv_rec.end_date := l_rdsv_rec.end_date;
2159: END IF;
2160: IF (x_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM)

Line 2160: IF (x_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM)

2156: IF (x_rdsv_rec.end_date = OKC_API.G_MISS_DATE)
2157: THEN
2158: x_rdsv_rec.end_date := l_rdsv_rec.end_date;
2159: END IF;
2160: IF (x_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM)
2161: THEN
2162: x_rdsv_rec.object_version_number := l_rdsv_rec.object_version_number;
2163: END IF;
2164: IF (x_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM)

Line 2164: IF (x_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM)

2160: IF (x_rdsv_rec.object_version_number = OKC_API.G_MISS_NUM)
2161: THEN
2162: x_rdsv_rec.object_version_number := l_rdsv_rec.object_version_number;
2163: END IF;
2164: IF (x_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM)
2165: THEN
2166: x_rdsv_rec.object_id_number := l_rdsv_rec.object_id_number;
2167: END IF;
2168: IF (x_rdsv_rec.created_by = OKC_API.G_MISS_NUM)

Line 2168: IF (x_rdsv_rec.created_by = OKC_API.G_MISS_NUM)

2164: IF (x_rdsv_rec.object_id_number = OKC_API.G_MISS_NUM)
2165: THEN
2166: x_rdsv_rec.object_id_number := l_rdsv_rec.object_id_number;
2167: END IF;
2168: IF (x_rdsv_rec.created_by = OKC_API.G_MISS_NUM)
2169: THEN
2170: x_rdsv_rec.created_by := l_rdsv_rec.created_by;
2171: END IF;
2172: IF (x_rdsv_rec.creation_date = OKC_API.G_MISS_DATE)

Line 2172: IF (x_rdsv_rec.creation_date = OKC_API.G_MISS_DATE)

2168: IF (x_rdsv_rec.created_by = OKC_API.G_MISS_NUM)
2169: THEN
2170: x_rdsv_rec.created_by := l_rdsv_rec.created_by;
2171: END IF;
2172: IF (x_rdsv_rec.creation_date = OKC_API.G_MISS_DATE)
2173: THEN
2174: x_rdsv_rec.creation_date := l_rdsv_rec.creation_date;
2175: END IF;
2176: IF (x_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM)

Line 2176: IF (x_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM)

2172: IF (x_rdsv_rec.creation_date = OKC_API.G_MISS_DATE)
2173: THEN
2174: x_rdsv_rec.creation_date := l_rdsv_rec.creation_date;
2175: END IF;
2176: IF (x_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM)
2177: THEN
2178: x_rdsv_rec.last_updated_by := l_rdsv_rec.last_updated_by;
2179: END IF;
2180: IF (x_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE)

Line 2180: IF (x_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE)

2176: IF (x_rdsv_rec.last_updated_by = OKC_API.G_MISS_NUM)
2177: THEN
2178: x_rdsv_rec.last_updated_by := l_rdsv_rec.last_updated_by;
2179: END IF;
2180: IF (x_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE)
2181: THEN
2182: x_rdsv_rec.last_update_date := l_rdsv_rec.last_update_date;
2183: END IF;
2184: IF (x_rdsv_rec.last_update_login = OKC_API.G_MISS_NUM)

Line 2184: IF (x_rdsv_rec.last_update_login = OKC_API.G_MISS_NUM)

2180: IF (x_rdsv_rec.last_update_date = OKC_API.G_MISS_DATE)
2181: THEN
2182: x_rdsv_rec.last_update_date := l_rdsv_rec.last_update_date;
2183: END IF;
2184: IF (x_rdsv_rec.last_update_login = OKC_API.G_MISS_NUM)
2185: THEN
2186: x_rdsv_rec.last_update_login := l_rdsv_rec.last_update_login;
2187: END IF;
2188: RETURN(l_return_status);

Line 2197: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2193: FUNCTION Set_Attributes (
2194: p_rdsv_rec IN rdsv_rec_type,
2195: x_rdsv_rec OUT NOCOPY rdsv_rec_type
2196: ) RETURN VARCHAR2 IS
2197: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2198: BEGIN
2199: x_rdsv_rec := p_rdsv_rec;
2200: x_rdsv_rec.OBJECT_VERSION_NUMBER := NVL(x_rdsv_rec.OBJECT_VERSION_NUMBER, 0) + 1;
2201: RETURN(l_return_status);

Line 2204: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2200: x_rdsv_rec.OBJECT_VERSION_NUMBER := NVL(x_rdsv_rec.OBJECT_VERSION_NUMBER, 0) + 1;
2201: RETURN(l_return_status);
2202: END Set_Attributes;
2203: BEGIN
2204: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2205: G_PKG_NAME,
2206: p_init_msg_list,
2207: l_api_version,
2208: p_api_version,

Line 2211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2207: l_api_version,
2208: p_api_version,
2209: '_PVT',
2210: x_return_status);
2211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2212: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2214: RAISE OKC_API.G_EXCEPTION_ERROR;
2215: END IF;

Line 2212: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2208: p_api_version,
2209: '_PVT',
2210: x_return_status);
2211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2212: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2214: RAISE OKC_API.G_EXCEPTION_ERROR;
2215: END IF;
2216: --- Setting item attributes

Line 2213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2209: '_PVT',
2210: x_return_status);
2211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2212: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2214: RAISE OKC_API.G_EXCEPTION_ERROR;
2215: END IF;
2216: --- Setting item attributes
2217: l_return_status := Set_Attributes(

Line 2214: RAISE OKC_API.G_EXCEPTION_ERROR;

2210: x_return_status);
2211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2212: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2214: RAISE OKC_API.G_EXCEPTION_ERROR;
2215: END IF;
2216: --- Setting item attributes
2217: l_return_status := Set_Attributes(
2218: p_rdsv_rec, -- IN

Line 2221: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2217: l_return_status := Set_Attributes(
2218: p_rdsv_rec, -- IN
2219: l_rdsv_rec); -- OUT
2220: --- If any errors happen abort API
2221: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2222: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2223: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2224: RAISE OKC_API.G_EXCEPTION_ERROR;
2225: END IF;

Line 2222: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2218: p_rdsv_rec, -- IN
2219: l_rdsv_rec); -- OUT
2220: --- If any errors happen abort API
2221: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2222: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2223: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2224: RAISE OKC_API.G_EXCEPTION_ERROR;
2225: END IF;
2226: l_return_status := populate_new_record(l_rdsv_rec, l_def_rdsv_rec);

Line 2223: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2219: l_rdsv_rec); -- OUT
2220: --- If any errors happen abort API
2221: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2222: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2223: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2224: RAISE OKC_API.G_EXCEPTION_ERROR;
2225: END IF;
2226: l_return_status := populate_new_record(l_rdsv_rec, l_def_rdsv_rec);
2227: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2224: RAISE OKC_API.G_EXCEPTION_ERROR;

2220: --- If any errors happen abort API
2221: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2222: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2223: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2224: RAISE OKC_API.G_EXCEPTION_ERROR;
2225: END IF;
2226: l_return_status := populate_new_record(l_rdsv_rec, l_def_rdsv_rec);
2227: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2228: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

Line 2227: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2223: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2224: RAISE OKC_API.G_EXCEPTION_ERROR;
2225: END IF;
2226: l_return_status := populate_new_record(l_rdsv_rec, l_def_rdsv_rec);
2227: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2228: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2229: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2230: RAISE OKC_API.G_EXCEPTION_ERROR;
2231: END IF;

Line 2228: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2224: RAISE OKC_API.G_EXCEPTION_ERROR;
2225: END IF;
2226: l_return_status := populate_new_record(l_rdsv_rec, l_def_rdsv_rec);
2227: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2228: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2229: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2230: RAISE OKC_API.G_EXCEPTION_ERROR;
2231: END IF;
2232: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);

Line 2229: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2225: END IF;
2226: l_return_status := populate_new_record(l_rdsv_rec, l_def_rdsv_rec);
2227: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2228: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2229: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2230: RAISE OKC_API.G_EXCEPTION_ERROR;
2231: END IF;
2232: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);
2233: --- Validate all non-missing attributes (Item Level Validation)

Line 2230: RAISE OKC_API.G_EXCEPTION_ERROR;

2226: l_return_status := populate_new_record(l_rdsv_rec, l_def_rdsv_rec);
2227: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2228: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2229: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2230: RAISE OKC_API.G_EXCEPTION_ERROR;
2231: END IF;
2232: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);
2233: --- Validate all non-missing attributes (Item Level Validation)
2234: l_return_status := Validate_Attributes(l_def_rdsv_rec);

Line 2236: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2232: l_def_rdsv_rec := fill_who_columns(l_def_rdsv_rec);
2233: --- Validate all non-missing attributes (Item Level Validation)
2234: l_return_status := Validate_Attributes(l_def_rdsv_rec);
2235: --- If any errors happen abort API
2236: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2237: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2238: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2239: RAISE OKC_API.G_EXCEPTION_ERROR;
2240: END IF;

Line 2237: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2233: --- Validate all non-missing attributes (Item Level Validation)
2234: l_return_status := Validate_Attributes(l_def_rdsv_rec);
2235: --- If any errors happen abort API
2236: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2237: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2238: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2239: RAISE OKC_API.G_EXCEPTION_ERROR;
2240: END IF;
2241: l_return_status := Validate_Record(l_def_rdsv_rec);

Line 2238: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2234: l_return_status := Validate_Attributes(l_def_rdsv_rec);
2235: --- If any errors happen abort API
2236: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2237: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2238: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2239: RAISE OKC_API.G_EXCEPTION_ERROR;
2240: END IF;
2241: l_return_status := Validate_Record(l_def_rdsv_rec);
2242: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2239: RAISE OKC_API.G_EXCEPTION_ERROR;

2235: --- If any errors happen abort API
2236: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2237: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2238: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2239: RAISE OKC_API.G_EXCEPTION_ERROR;
2240: END IF;
2241: l_return_status := Validate_Record(l_def_rdsv_rec);
2242: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2243: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

Line 2242: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2238: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2239: RAISE OKC_API.G_EXCEPTION_ERROR;
2240: END IF;
2241: l_return_status := Validate_Record(l_def_rdsv_rec);
2242: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2243: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2244: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2245: RAISE OKC_API.G_EXCEPTION_ERROR;
2246: END IF;

Line 2243: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2239: RAISE OKC_API.G_EXCEPTION_ERROR;
2240: END IF;
2241: l_return_status := Validate_Record(l_def_rdsv_rec);
2242: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2243: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2244: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2245: RAISE OKC_API.G_EXCEPTION_ERROR;
2246: END IF;
2247:

Line 2244: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2240: END IF;
2241: l_return_status := Validate_Record(l_def_rdsv_rec);
2242: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2243: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2244: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2245: RAISE OKC_API.G_EXCEPTION_ERROR;
2246: END IF;
2247:
2248: --------------------------------------

Line 2245: RAISE OKC_API.G_EXCEPTION_ERROR;

2241: l_return_status := Validate_Record(l_def_rdsv_rec);
2242: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2243: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2244: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2245: RAISE OKC_API.G_EXCEPTION_ERROR;
2246: END IF;
2247:
2248: --------------------------------------
2249: -- Move VIEW record to "Child" records

Line 2263: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2259: x_msg_data,
2260: l_rds_rec,
2261: lx_rds_rec
2262: );
2263: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2264: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2265: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2266: RAISE OKC_API.G_EXCEPTION_ERROR;
2267: END IF;

Line 2264: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2260: l_rds_rec,
2261: lx_rds_rec
2262: );
2263: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2264: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2265: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2266: RAISE OKC_API.G_EXCEPTION_ERROR;
2267: END IF;
2268: migrate(lx_rds_rec, l_def_rdsv_rec);

Line 2265: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2261: lx_rds_rec
2262: );
2263: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2264: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2265: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2266: RAISE OKC_API.G_EXCEPTION_ERROR;
2267: END IF;
2268: migrate(lx_rds_rec, l_def_rdsv_rec);
2269: x_rdsv_rec := l_def_rdsv_rec;

Line 2266: RAISE OKC_API.G_EXCEPTION_ERROR;

2262: );
2263: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2264: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2265: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2266: RAISE OKC_API.G_EXCEPTION_ERROR;
2267: END IF;
2268: migrate(lx_rds_rec, l_def_rdsv_rec);
2269: x_rdsv_rec := l_def_rdsv_rec;
2270: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 2270: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2266: RAISE OKC_API.G_EXCEPTION_ERROR;
2267: END IF;
2268: migrate(lx_rds_rec, l_def_rdsv_rec);
2269: x_rdsv_rec := l_def_rdsv_rec;
2270: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2271: EXCEPTION
2272: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2273: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2274: (

Line 2272: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2268: migrate(lx_rds_rec, l_def_rdsv_rec);
2269: x_rdsv_rec := l_def_rdsv_rec;
2270: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2271: EXCEPTION
2272: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2273: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2274: (
2275: l_api_name,
2276: G_PKG_NAME,

Line 2273: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2269: x_rdsv_rec := l_def_rdsv_rec;
2270: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2271: EXCEPTION
2272: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2273: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2274: (
2275: l_api_name,
2276: G_PKG_NAME,
2277: 'OKC_API.G_RET_STS_ERROR',

Line 2277: 'OKC_API.G_RET_STS_ERROR',

2273: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2274: (
2275: l_api_name,
2276: G_PKG_NAME,
2277: 'OKC_API.G_RET_STS_ERROR',
2278: x_msg_count,
2279: x_msg_data,
2280: '_PVT'
2281: );

Line 2282: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2278: x_msg_count,
2279: x_msg_data,
2280: '_PVT'
2281: );
2282: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2283: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2284: (
2285: l_api_name,
2286: G_PKG_NAME,

Line 2283: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2279: x_msg_data,
2280: '_PVT'
2281: );
2282: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2283: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2284: (
2285: l_api_name,
2286: G_PKG_NAME,
2287: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2287: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2283: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2284: (
2285: l_api_name,
2286: G_PKG_NAME,
2287: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2288: x_msg_count,
2289: x_msg_data,
2290: '_PVT'
2291: );

Line 2293: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2289: x_msg_data,
2290: '_PVT'
2291: );
2292: WHEN OTHERS THEN
2293: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2294: (
2295: l_api_name,
2296: G_PKG_NAME,
2297: 'OTHERS',

Line 2317: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2313: x_rdsv_tbl OUT NOCOPY rdsv_tbl_type) IS
2314:
2315: l_api_version CONSTANT NUMBER := 1;
2316: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
2317: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2318: i NUMBER := 0;
2319: BEGIN
2320: OKC_API.init_msg_list(p_init_msg_list);
2321: -- Make sure PL/SQL table has records in it before passing

Line 2320: OKC_API.init_msg_list(p_init_msg_list);

2316: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
2317: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2318: i NUMBER := 0;
2319: BEGIN
2320: OKC_API.init_msg_list(p_init_msg_list);
2321: -- Make sure PL/SQL table has records in it before passing
2322: IF (p_rdsv_tbl.COUNT > 0) THEN
2323: i := p_rdsv_tbl.FIRST;
2324: LOOP

Line 2327: p_init_msg_list => OKC_API.G_FALSE,

2323: i := p_rdsv_tbl.FIRST;
2324: LOOP
2325: update_row (
2326: p_api_version => p_api_version,
2327: p_init_msg_list => OKC_API.G_FALSE,
2328: x_return_status => x_return_status,
2329: x_msg_count => x_msg_count,
2330: x_msg_data => x_msg_data,
2331: p_rdsv_rec => p_rdsv_tbl(i),

Line 2338: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2334: i := p_rdsv_tbl.NEXT(i);
2335: END LOOP;
2336: END IF;
2337: EXCEPTION
2338: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2339: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2340: (
2341: l_api_name,
2342: G_PKG_NAME,

Line 2339: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2335: END LOOP;
2336: END IF;
2337: EXCEPTION
2338: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2339: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2340: (
2341: l_api_name,
2342: G_PKG_NAME,
2343: 'OKC_API.G_RET_STS_ERROR',

Line 2343: 'OKC_API.G_RET_STS_ERROR',

2339: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2340: (
2341: l_api_name,
2342: G_PKG_NAME,
2343: 'OKC_API.G_RET_STS_ERROR',
2344: x_msg_count,
2345: x_msg_data,
2346: '_PVT'
2347: );

Line 2348: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2344: x_msg_count,
2345: x_msg_data,
2346: '_PVT'
2347: );
2348: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2349: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2350: (
2351: l_api_name,
2352: G_PKG_NAME,

Line 2349: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2345: x_msg_data,
2346: '_PVT'
2347: );
2348: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2349: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2350: (
2351: l_api_name,
2352: G_PKG_NAME,
2353: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2353: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2349: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2350: (
2351: l_api_name,
2352: G_PKG_NAME,
2353: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2354: x_msg_count,
2355: x_msg_data,
2356: '_PVT'
2357: );

Line 2359: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2355: x_msg_data,
2356: '_PVT'
2357: );
2358: WHEN OTHERS THEN
2359: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2360: (
2361: l_api_name,
2362: G_PKG_NAME,
2363: 'OTHERS',

Line 2385: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2381: p_rds_rec IN rds_rec_type) IS
2382:
2383: l_api_version CONSTANT NUMBER := 1;
2384: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_delete_row';
2385: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2386: l_rds_rec rds_rec_type:= p_rds_rec;
2387: l_row_notfound BOOLEAN := TRUE;
2388: BEGIN
2389: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 2389: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2385: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2386: l_rds_rec rds_rec_type:= p_rds_rec;
2387: l_row_notfound BOOLEAN := TRUE;
2388: BEGIN
2389: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2390: p_init_msg_list,
2391: '_PVT',
2392: x_return_status);
2393: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 2393: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2389: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2390: p_init_msg_list,
2391: '_PVT',
2392: x_return_status);
2393: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2394: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2395: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2396: RAISE OKC_API.G_EXCEPTION_ERROR;
2397: END IF;

Line 2394: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2390: p_init_msg_list,
2391: '_PVT',
2392: x_return_status);
2393: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2394: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2395: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2396: RAISE OKC_API.G_EXCEPTION_ERROR;
2397: END IF;
2398: DELETE FROM OKC_RULE_DEF_SOURCES

Line 2395: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2391: '_PVT',
2392: x_return_status);
2393: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2394: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2395: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2396: RAISE OKC_API.G_EXCEPTION_ERROR;
2397: END IF;
2398: DELETE FROM OKC_RULE_DEF_SOURCES
2399: WHERE BUY_OR_SELL = l_rds_rec.buy_or_sell

Line 2396: RAISE OKC_API.G_EXCEPTION_ERROR;

2392: x_return_status);
2393: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2394: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2395: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2396: RAISE OKC_API.G_EXCEPTION_ERROR;
2397: END IF;
2398: DELETE FROM OKC_RULE_DEF_SOURCES
2399: WHERE BUY_OR_SELL = l_rds_rec.buy_or_sell
2400: AND RGR_RGD_CODE = l_rds_rec.rgr_rgd_code

Line 2405: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2401: AND RGR_RDF_CODE = l_rds_rec.rgr_rdf_code
2402: AND TRUNC(START_DATE) = TRUNC(l_rds_rec.start_date)
2403: AND OBJECT_ID_NUMBER = l_rds_rec.object_id_number;
2404:
2405: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2406: EXCEPTION
2407: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2408: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2409: (

Line 2407: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2403: AND OBJECT_ID_NUMBER = l_rds_rec.object_id_number;
2404:
2405: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2406: EXCEPTION
2407: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2408: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2409: (
2410: l_api_name,
2411: G_PKG_NAME,

Line 2408: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2404:
2405: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2406: EXCEPTION
2407: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2408: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2409: (
2410: l_api_name,
2411: G_PKG_NAME,
2412: 'OKC_API.G_RET_STS_ERROR',

Line 2412: 'OKC_API.G_RET_STS_ERROR',

2408: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2409: (
2410: l_api_name,
2411: G_PKG_NAME,
2412: 'OKC_API.G_RET_STS_ERROR',
2413: x_msg_count,
2414: x_msg_data,
2415: '_PVT'
2416: );

Line 2417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2413: x_msg_count,
2414: x_msg_data,
2415: '_PVT'
2416: );
2417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2418: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2419: (
2420: l_api_name,
2421: G_PKG_NAME,

Line 2418: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2414: x_msg_data,
2415: '_PVT'
2416: );
2417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2418: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2419: (
2420: l_api_name,
2421: G_PKG_NAME,
2422: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2422: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2418: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2419: (
2420: l_api_name,
2421: G_PKG_NAME,
2422: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2423: x_msg_count,
2424: x_msg_data,
2425: '_PVT'
2426: );

Line 2428: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2424: x_msg_data,
2425: '_PVT'
2426: );
2427: WHEN OTHERS THEN
2428: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2429: (
2430: l_api_name,
2431: G_PKG_NAME,
2432: 'OTHERS',

Line 2451: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2447: p_rdsv_rec IN rdsv_rec_type) IS
2448:
2449: l_api_version CONSTANT NUMBER := 1;
2450: l_api_name CONSTANT VARCHAR2(30) := 'V_delete_row';
2451: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2452: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
2453: l_rds_rec rds_rec_type;
2454: BEGIN
2455: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 2455: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

2451: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2452: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
2453: l_rds_rec rds_rec_type;
2454: BEGIN
2455: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2456: G_PKG_NAME,
2457: p_init_msg_list,
2458: l_api_version,
2459: p_api_version,

Line 2462: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2458: l_api_version,
2459: p_api_version,
2460: '_PVT',
2461: x_return_status);
2462: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2464: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2465: RAISE OKC_API.G_EXCEPTION_ERROR;
2466: END IF;

Line 2463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2459: p_api_version,
2460: '_PVT',
2461: x_return_status);
2462: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2464: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2465: RAISE OKC_API.G_EXCEPTION_ERROR;
2466: END IF;
2467: --------------------------------------

Line 2464: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

2460: '_PVT',
2461: x_return_status);
2462: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2464: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2465: RAISE OKC_API.G_EXCEPTION_ERROR;
2466: END IF;
2467: --------------------------------------
2468: -- Move VIEW record to "Child" records

Line 2465: RAISE OKC_API.G_EXCEPTION_ERROR;

2461: x_return_status);
2462: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2463: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2464: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2465: RAISE OKC_API.G_EXCEPTION_ERROR;
2466: END IF;
2467: --------------------------------------
2468: -- Move VIEW record to "Child" records
2469: --------------------------------------

Line 2481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

2477: x_msg_count,
2478: x_msg_data,
2479: l_rds_rec
2480: );
2481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2482: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2484: RAISE OKC_API.G_EXCEPTION_ERROR;
2485: END IF;

Line 2482: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2478: x_msg_data,
2479: l_rds_rec
2480: );
2481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2482: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2484: RAISE OKC_API.G_EXCEPTION_ERROR;
2485: END IF;
2486: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 2483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

2479: l_rds_rec
2480: );
2481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2482: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2484: RAISE OKC_API.G_EXCEPTION_ERROR;
2485: END IF;
2486: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2487: EXCEPTION

Line 2484: RAISE OKC_API.G_EXCEPTION_ERROR;

2480: );
2481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2482: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2484: RAISE OKC_API.G_EXCEPTION_ERROR;
2485: END IF;
2486: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2487: EXCEPTION
2488: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 2486: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

2482: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2484: RAISE OKC_API.G_EXCEPTION_ERROR;
2485: END IF;
2486: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2487: EXCEPTION
2488: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2489: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2490: (

Line 2488: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2484: RAISE OKC_API.G_EXCEPTION_ERROR;
2485: END IF;
2486: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2487: EXCEPTION
2488: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2489: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2490: (
2491: l_api_name,
2492: G_PKG_NAME,

Line 2489: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2485: END IF;
2486: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2487: EXCEPTION
2488: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2489: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2490: (
2491: l_api_name,
2492: G_PKG_NAME,
2493: 'OKC_API.G_RET_STS_ERROR',

Line 2493: 'OKC_API.G_RET_STS_ERROR',

2489: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2490: (
2491: l_api_name,
2492: G_PKG_NAME,
2493: 'OKC_API.G_RET_STS_ERROR',
2494: x_msg_count,
2495: x_msg_data,
2496: '_PVT'
2497: );

Line 2498: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2494: x_msg_count,
2495: x_msg_data,
2496: '_PVT'
2497: );
2498: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2499: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2500: (
2501: l_api_name,
2502: G_PKG_NAME,

Line 2499: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2495: x_msg_data,
2496: '_PVT'
2497: );
2498: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2499: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2500: (
2501: l_api_name,
2502: G_PKG_NAME,
2503: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2503: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2499: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2500: (
2501: l_api_name,
2502: G_PKG_NAME,
2503: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2504: x_msg_count,
2505: x_msg_data,
2506: '_PVT'
2507: );

Line 2509: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2505: x_msg_data,
2506: '_PVT'
2507: );
2508: WHEN OTHERS THEN
2509: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2510: (
2511: l_api_name,
2512: G_PKG_NAME,
2513: 'OTHERS',

Line 2532: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

2528: p_rdsv_tbl IN rdsv_tbl_type) IS
2529:
2530: l_api_version CONSTANT NUMBER := 1;
2531: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
2532: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2533: i NUMBER := 0;
2534: BEGIN
2535: OKC_API.init_msg_list(p_init_msg_list);
2536: -- Make sure PL/SQL table has records in it before passing

Line 2535: OKC_API.init_msg_list(p_init_msg_list);

2531: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
2532: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2533: i NUMBER := 0;
2534: BEGIN
2535: OKC_API.init_msg_list(p_init_msg_list);
2536: -- Make sure PL/SQL table has records in it before passing
2537: IF (p_rdsv_tbl.COUNT > 0) THEN
2538: i := p_rdsv_tbl.FIRST;
2539: LOOP

Line 2542: p_init_msg_list => OKC_API.G_FALSE,

2538: i := p_rdsv_tbl.FIRST;
2539: LOOP
2540: delete_row (
2541: p_api_version => p_api_version,
2542: p_init_msg_list => OKC_API.G_FALSE,
2543: x_return_status => x_return_status,
2544: x_msg_count => x_msg_count,
2545: x_msg_data => x_msg_data,
2546: p_rdsv_rec => p_rdsv_tbl(i));

Line 2552: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2548: i := p_rdsv_tbl.NEXT(i);
2549: END LOOP;
2550: END IF;
2551: EXCEPTION
2552: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2553: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2554: (
2555: l_api_name,
2556: G_PKG_NAME,

Line 2553: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2549: END LOOP;
2550: END IF;
2551: EXCEPTION
2552: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2553: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2554: (
2555: l_api_name,
2556: G_PKG_NAME,
2557: 'OKC_API.G_RET_STS_ERROR',

Line 2557: 'OKC_API.G_RET_STS_ERROR',

2553: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2554: (
2555: l_api_name,
2556: G_PKG_NAME,
2557: 'OKC_API.G_RET_STS_ERROR',
2558: x_msg_count,
2559: x_msg_data,
2560: '_PVT'
2561: );

Line 2562: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2558: x_msg_count,
2559: x_msg_data,
2560: '_PVT'
2561: );
2562: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2563: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2564: (
2565: l_api_name,
2566: G_PKG_NAME,

Line 2563: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2559: x_msg_data,
2560: '_PVT'
2561: );
2562: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2563: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2564: (
2565: l_api_name,
2566: G_PKG_NAME,
2567: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2567: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2563: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2564: (
2565: l_api_name,
2566: G_PKG_NAME,
2567: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2568: x_msg_count,
2569: x_msg_data,
2570: '_PVT'
2571: );

Line 2573: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

2569: x_msg_data,
2570: '_PVT'
2571: );
2572: WHEN OTHERS THEN
2573: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2574: (
2575: l_api_name,
2576: G_PKG_NAME,
2577: 'OTHERS',