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_RSC_PVT dependencies on OKC_API

Line 9: g_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;

5: /*+++++++++++++Start of hand code +++++++++++++++++*/
6: G_UNEXPECTED_ERROR CONSTANT varchar2(200) := 'OKC_UNEXPECTED_ERROR';
7: G_SQLCODE_TOKEN CONSTANT varchar2(200) := 'ERROR_CODE';
8: G_SQLERRM_TOKEN CONSTANT varchar2(200) := 'ERROR_MESSAGE';
9: g_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;
10: G_EXCEPTION_HALT_VALIDATION exception;
11: /*+++++++++++++End of hand code +++++++++++++++++++*/
12: ---------------------------------------------------------------------------
13: -- FUNCTION get_seq_id

Line 173: IF (l_rscv_rec.end_date = OKC_API.G_MISS_DATE) THEN

169: p_rscv_rec IN rscv_rec_type
170: ) RETURN rscv_rec_type IS
171: l_rscv_rec rscv_rec_type := p_rscv_rec;
172: BEGIN
173: IF (l_rscv_rec.end_date = OKC_API.G_MISS_DATE) THEN
174: l_rscv_rec.end_date := NULL;
175: END IF;
176: IF (l_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) THEN
177: l_rscv_rec.JTOT_OBJECT_CODE := NULL;

Line 176: IF (l_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) THEN

172: BEGIN
173: IF (l_rscv_rec.end_date = OKC_API.G_MISS_DATE) THEN
174: l_rscv_rec.end_date := NULL;
175: END IF;
176: IF (l_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) THEN
177: l_rscv_rec.JTOT_OBJECT_CODE := NULL;
178: END IF;
179: IF (l_rscv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
180: l_rscv_rec.object_version_number := NULL;

Line 179: IF (l_rscv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN

175: END IF;
176: IF (l_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) THEN
177: l_rscv_rec.JTOT_OBJECT_CODE := NULL;
178: END IF;
179: IF (l_rscv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
180: l_rscv_rec.object_version_number := NULL;
181: END IF;
182: IF (l_rscv_rec.created_by = OKC_API.G_MISS_NUM) THEN
183: l_rscv_rec.created_by := NULL;

Line 182: IF (l_rscv_rec.created_by = OKC_API.G_MISS_NUM) THEN

178: END IF;
179: IF (l_rscv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
180: l_rscv_rec.object_version_number := NULL;
181: END IF;
182: IF (l_rscv_rec.created_by = OKC_API.G_MISS_NUM) THEN
183: l_rscv_rec.created_by := NULL;
184: END IF;
185: IF (l_rscv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
186: l_rscv_rec.creation_date := NULL;

Line 185: IF (l_rscv_rec.creation_date = OKC_API.G_MISS_DATE) THEN

181: END IF;
182: IF (l_rscv_rec.created_by = OKC_API.G_MISS_NUM) THEN
183: l_rscv_rec.created_by := NULL;
184: END IF;
185: IF (l_rscv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
186: l_rscv_rec.creation_date := NULL;
187: END IF;
188: IF (l_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
189: l_rscv_rec.last_updated_by := NULL;

Line 188: IF (l_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN

184: END IF;
185: IF (l_rscv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
186: l_rscv_rec.creation_date := NULL;
187: END IF;
188: IF (l_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
189: l_rscv_rec.last_updated_by := NULL;
190: END IF;
191: IF (l_rscv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
192: l_rscv_rec.last_update_date := NULL;

Line 191: IF (l_rscv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN

187: END IF;
188: IF (l_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
189: l_rscv_rec.last_updated_by := NULL;
190: END IF;
191: IF (l_rscv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
192: l_rscv_rec.last_update_date := NULL;
193: END IF;
194: IF (l_rscv_rec.last_update_login= OKC_API.G_MISS_NUM) THEN
195: l_rscv_rec.last_update_login := NULL;

Line 194: IF (l_rscv_rec.last_update_login= OKC_API.G_MISS_NUM) THEN

190: END IF;
191: IF (l_rscv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
192: l_rscv_rec.last_update_date := NULL;
193: END IF;
194: IF (l_rscv_rec.last_update_login= OKC_API.G_MISS_NUM) THEN
195: l_rscv_rec.last_update_login := NULL;
196: END IF;
197: IF (l_rscv_rec.access_level = OKC_API.G_MISS_CHAR) THEN
198: l_rscv_rec.access_level := NULL;

Line 197: IF (l_rscv_rec.access_level = OKC_API.G_MISS_CHAR) THEN

193: END IF;
194: IF (l_rscv_rec.last_update_login= OKC_API.G_MISS_NUM) THEN
195: l_rscv_rec.last_update_login := NULL;
196: END IF;
197: IF (l_rscv_rec.access_level = OKC_API.G_MISS_CHAR) THEN
198: l_rscv_rec.access_level := NULL;
199: END IF;
200: RETURN(l_rscv_rec);
201: END null_out_defaults;

Line 217: x_return_status := OKC_API.G_RET_STS_SUCCESS;

213: -- End of comments
214: procedure validate_rle_code(x_return_status OUT NOCOPY VARCHAR2,
215: p_rscv_rec IN RSCV_REC_TYPE) is
216: begin
217: x_return_status := OKC_API.G_RET_STS_SUCCESS;
218: --1
219: if (p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR) then
220: return;
221: end if;

Line 219: if (p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR) then

215: p_rscv_rec IN RSCV_REC_TYPE) is
216: begin
217: x_return_status := OKC_API.G_RET_STS_SUCCESS;
218: --1
219: if (p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR) then
220: return;
221: end if;
222: --2
223: if (p_rscv_rec.rle_code is NULL) then

Line 224: OKC_API.set_message(p_app_name => g_app_name,

220: return;
221: end if;
222: --2
223: if (p_rscv_rec.rle_code is NULL) then
224: OKC_API.set_message(p_app_name => g_app_name,
225: p_msg_name => G_REQUIRED_VALUE,
226: p_token1 => G_COL_NAME_TOKEN,
227: p_token1_value => 'RLE_CODE');
228: raise G_EXCEPTION_HALT_VALIDATION;

Line 232: if (x_return_status <> OKC_API.G_RET_STS_SUCCESS) then

228: raise G_EXCEPTION_HALT_VALIDATION;
229: end if;
230: --3
231: x_return_status := OKC_UTIL.check_lookup_code('OKC_ROLE',p_rscv_rec.rle_code);
232: if (x_return_status <> OKC_API.G_RET_STS_SUCCESS) then
233: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'RLE_CODE');
234: raise G_EXCEPTION_HALT_VALIDATION;
235: end if;
236: exception

Line 233: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'RLE_CODE');

229: end if;
230: --3
231: x_return_status := OKC_UTIL.check_lookup_code('OKC_ROLE',p_rscv_rec.rle_code);
232: if (x_return_status <> OKC_API.G_RET_STS_SUCCESS) then
233: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'RLE_CODE');
234: raise G_EXCEPTION_HALT_VALIDATION;
235: end if;
236: exception
237: when G_EXCEPTION_HALT_VALIDATION then

Line 238: x_return_status := OKC_API.G_RET_STS_ERROR;

234: raise G_EXCEPTION_HALT_VALIDATION;
235: end if;
236: exception
237: when G_EXCEPTION_HALT_VALIDATION then
238: x_return_status := OKC_API.G_RET_STS_ERROR;
239: when OTHERS then
240: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
241: p_msg_name => g_unexpected_error,
242: p_token1 => g_sqlcode_token,

Line 240: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

236: exception
237: when G_EXCEPTION_HALT_VALIDATION then
238: x_return_status := OKC_API.G_RET_STS_ERROR;
239: when OTHERS then
240: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
241: p_msg_name => g_unexpected_error,
242: p_token1 => g_sqlcode_token,
243: p_token1_value => sqlcode,
244: p_token2 => g_sqlerrm_token,

Line 246: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

242: p_token1 => g_sqlcode_token,
243: p_token1_value => sqlcode,
244: p_token2 => g_sqlerrm_token,
245: p_token2_value => sqlerrm);
246: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
247: end validate_rle_code;
248:
249:
250: -- Start of comments

Line 261: x_return_status := OKC_API.G_RET_STS_SUCCESS;

257: -- End of comments
258: procedure validate_buy_or_sell(x_return_status OUT NOCOPY VARCHAR2,
259: p_rscv_rec IN RSCV_REC_TYPE) is
260: begin
261: x_return_status := OKC_API.G_RET_STS_SUCCESS;
262: --1
263: if (P_RSCV_REC.buy_or_sell in ('B','S',OKC_API.G_MISS_CHAR)) then
264: return;
265: end if;

Line 263: if (P_RSCV_REC.buy_or_sell in ('B','S',OKC_API.G_MISS_CHAR)) then

259: p_rscv_rec IN RSCV_REC_TYPE) is
260: begin
261: x_return_status := OKC_API.G_RET_STS_SUCCESS;
262: --1
263: if (P_RSCV_REC.buy_or_sell in ('B','S',OKC_API.G_MISS_CHAR)) then
264: return;
265: end if;
266: --2
267: if (P_RSCV_REC.buy_or_sell is NULL) then

Line 268: OKC_API.set_message(p_app_name => g_app_name,

264: return;
265: end if;
266: --2
267: if (P_RSCV_REC.buy_or_sell is NULL) then
268: OKC_API.set_message(p_app_name => g_app_name,
269: p_msg_name => G_REQUIRED_VALUE,
270: p_token1 => G_COL_NAME_TOKEN,
271: p_token1_value => 'BUY_OR_SELL');
272: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 272: x_return_status := OKC_API.G_RET_STS_ERROR;

268: OKC_API.set_message(p_app_name => g_app_name,
269: p_msg_name => G_REQUIRED_VALUE,
270: p_token1 => G_COL_NAME_TOKEN,
271: p_token1_value => 'BUY_OR_SELL');
272: x_return_status := OKC_API.G_RET_STS_ERROR;
273: return;
274: end if;
275: --3
276: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'BUY_OR_SELL');

Line 276: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'BUY_OR_SELL');

272: x_return_status := OKC_API.G_RET_STS_ERROR;
273: return;
274: end if;
275: --3
276: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'BUY_OR_SELL');
277: x_return_status := OKC_API.G_RET_STS_ERROR;
278: end validate_buy_or_sell;
279:
280: -- Start of comments

Line 277: x_return_status := OKC_API.G_RET_STS_ERROR;

273: return;
274: end if;
275: --3
276: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'BUY_OR_SELL');
277: x_return_status := OKC_API.G_RET_STS_ERROR;
278: end validate_buy_or_sell;
279:
280: -- Start of comments
281: --

Line 291: x_return_status := OKC_API.G_RET_STS_SUCCESS;

287: -- End of comments
288: procedure validate_start_date(x_return_status OUT NOCOPY VARCHAR2,
289: p_rscv_rec IN RSCV_REC_TYPE) is
290: begin
291: x_return_status := OKC_API.G_RET_STS_SUCCESS;
292: if (P_RSCV_REC.start_date is NULL) then
293: OKC_API.set_message(p_app_name => g_app_name,
294: p_msg_name => G_REQUIRED_VALUE,
295: p_token1 => G_COL_NAME_TOKEN,

Line 293: OKC_API.set_message(p_app_name => g_app_name,

289: p_rscv_rec IN RSCV_REC_TYPE) is
290: begin
291: x_return_status := OKC_API.G_RET_STS_SUCCESS;
292: if (P_RSCV_REC.start_date is NULL) then
293: OKC_API.set_message(p_app_name => g_app_name,
294: p_msg_name => G_REQUIRED_VALUE,
295: p_token1 => G_COL_NAME_TOKEN,
296: p_token1_value => 'START_DATE');
297: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 297: x_return_status := OKC_API.G_RET_STS_ERROR;

293: OKC_API.set_message(p_app_name => g_app_name,
294: p_msg_name => G_REQUIRED_VALUE,
295: p_token1 => G_COL_NAME_TOKEN,
296: p_token1_value => 'START_DATE');
297: x_return_status := OKC_API.G_RET_STS_ERROR;
298: return;
299: end if;
300: end validate_start_date;
301:

Line 326: x_return_status := OKC_API.G_RET_STS_SUCCESS;

322: and NVL(J.END_DATE_ACTIVE,sysdate)
323: and U.OBJECT_code = p_rscv_rec.JTOT_OBJECT_CODE
324: and U.object_user_code='OKX_ROLES';
325: begin
326: x_return_status := OKC_API.G_RET_STS_SUCCESS;
327: --1
328: if (p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) then
329: return;
330: end if;

Line 328: if (p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) then

324: and U.object_user_code='OKX_ROLES';
325: begin
326: x_return_status := OKC_API.G_RET_STS_SUCCESS;
327: --1
328: if (p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR) then
329: return;
330: end if;
331: --2
332: if (P_RSCV_REC.JTOT_OBJECT_CODE is NULL) then

Line 333: OKC_API.set_message(p_app_name => g_app_name,

329: return;
330: end if;
331: --2
332: if (P_RSCV_REC.JTOT_OBJECT_CODE is NULL) then
333: OKC_API.set_message(p_app_name => g_app_name,
334: p_msg_name => G_REQUIRED_VALUE,
335: p_token1 => G_COL_NAME_TOKEN,
336: p_token1_value => 'JTOT_OBJECT_CODE');
337: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 337: x_return_status := OKC_API.G_RET_STS_ERROR;

333: OKC_API.set_message(p_app_name => g_app_name,
334: p_msg_name => G_REQUIRED_VALUE,
335: p_token1 => G_COL_NAME_TOKEN,
336: p_token1_value => 'JTOT_OBJECT_CODE');
337: x_return_status := OKC_API.G_RET_STS_ERROR;
338: return;
339: end if;
340: --3
341: open l_object_csr;

Line 345: OKC_API.set_message(G_APP_NAME,G_INVALID_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');

341: open l_object_csr;
342: fetch l_object_csr into l_dummy_var;
343: close l_object_csr;
344: if (l_dummy_var = '?') then
345: OKC_API.set_message(G_APP_NAME,G_INVALID_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');
346: x_return_status := OKC_API.G_RET_STS_ERROR;
347: return;
348: end if;
349: --

Line 346: x_return_status := OKC_API.G_RET_STS_ERROR;

342: fetch l_object_csr into l_dummy_var;
343: close l_object_csr;
344: if (l_dummy_var = '?') then
345: OKC_API.set_message(G_APP_NAME,G_INVALID_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');
346: x_return_status := OKC_API.G_RET_STS_ERROR;
347: return;
348: end if;
349: --
350: exception

Line 355: OKC_API.set_message(p_app_name => g_app_name,

351: when OTHERS then
352: if l_object_csr%ISOPEN then
353: close l_object_csr;
354: end if;
355: OKC_API.set_message(p_app_name => g_app_name,
356: p_msg_name => g_unexpected_error,
357: p_token1 => g_sqlcode_token,
358: p_token1_value => sqlcode,
359: p_token2 => g_sqlerrm_token,

Line 361: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

357: p_token1 => g_sqlcode_token,
358: p_token1_value => sqlcode,
359: p_token2 => g_sqlerrm_token,
360: p_token2_value => sqlerrm);
361: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
362: end validate_JTOT_OBJECT_CODE;
363:
364: -- Start of comments
365: --

Line 378: x_return_status :=OKC_API.G_RET_STS_SUCCESS;

374: PROCEDURE validate_access_level(
375: p_rscv_rec IN rscv_rec_type,
376: x_return_status OUT NOCOPY VARCHAR2) IS
377: BEGIN
378: x_return_status :=OKC_API.G_RET_STS_SUCCESS;
379:
380: IF (p_rscv_rec.access_level = OKC_API.G_MISS_CHAR OR
381: p_rscv_rec.access_level IS NULL)
382: THEN

Line 380: IF (p_rscv_rec.access_level = OKC_API.G_MISS_CHAR OR

376: x_return_status OUT NOCOPY VARCHAR2) IS
377: BEGIN
378: x_return_status :=OKC_API.G_RET_STS_SUCCESS;
379:
380: IF (p_rscv_rec.access_level = OKC_API.G_MISS_CHAR OR
381: p_rscv_rec.access_level IS NULL)
382: THEN
383: raise G_EXCEPTION_HALT_VALIDATION;
384: END IF;

Line 386: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

382: THEN
383: raise G_EXCEPTION_HALT_VALIDATION;
384: END IF;
385: IF upper(p_rscv_rec.access_level) not in ('S','E','U') Then
386: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
387: p_msg_name => g_invalid_value,
388: p_token1 => g_col_name_token,
389: p_token1_value => 'Access Level');
390: x_return_status :=OKC_API.G_RET_STS_ERROR;

Line 390: x_return_status :=OKC_API.G_RET_STS_ERROR;

386: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
387: p_msg_name => g_invalid_value,
388: p_token1 => g_col_name_token,
389: p_token1_value => 'Access Level');
390: x_return_status :=OKC_API.G_RET_STS_ERROR;
391: End If;
392: exception
393: when G_EXCEPTION_HALT_VALIDATION then
394: null;

Line 396: OKC_API.SET_MESSAGE(p_app_name => g_app_name,

392: exception
393: when G_EXCEPTION_HALT_VALIDATION then
394: null;
395: when OTHERS then
396: OKC_API.SET_MESSAGE(p_app_name => g_app_name,
397: p_msg_name => g_unexpected_error,
398: p_token1 => g_sqlcode_token,
399: p_token1_value => sqlcode,
400: p_token2 => g_sqlerrm_token,

Line 403: x_return_status :=OKC_API.G_RET_STS_UNEXP_ERROR;

399: p_token1_value => sqlcode,
400: p_token2 => g_sqlerrm_token,
401: p_token2_value => sqlerrm );
402:
403: x_return_status :=OKC_API.G_RET_STS_UNEXP_ERROR;
404:
405: END validate_access_level;
406:
407: /*+++++++++++++End of hand code +++++++++++++++++++*/

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

411: ------------------------------------------------
412: FUNCTION Validate_Attributes (
413: p_rscv_rec IN rscv_rec_type
414: ) RETURN VARCHAR2 IS
415: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
416: /*-------------Commented in favor of hand code------
417: BEGIN
418: IF p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR OR
419: p_rscv_rec.rle_code IS NULL

Line 418: IF p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR OR

414: ) RETURN VARCHAR2 IS
415: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
416: /*-------------Commented in favor of hand code------
417: BEGIN
418: IF p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR OR
419: p_rscv_rec.rle_code IS NULL
420: THEN
421: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rle_code');
422: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 421: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rle_code');

417: BEGIN
418: IF p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR OR
419: p_rscv_rec.rle_code IS NULL
420: THEN
421: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rle_code');
422: l_return_status := OKC_API.G_RET_STS_ERROR;
423: ELSIF p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
424: p_rscv_rec.buy_or_sell IS NULL
425: THEN

Line 422: l_return_status := OKC_API.G_RET_STS_ERROR;

418: IF p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR OR
419: p_rscv_rec.rle_code IS NULL
420: THEN
421: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rle_code');
422: l_return_status := OKC_API.G_RET_STS_ERROR;
423: ELSIF p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
424: p_rscv_rec.buy_or_sell IS NULL
425: THEN
426: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');

Line 423: ELSIF p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR

419: p_rscv_rec.rle_code IS NULL
420: THEN
421: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'rle_code');
422: l_return_status := OKC_API.G_RET_STS_ERROR;
423: ELSIF p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
424: p_rscv_rec.buy_or_sell IS NULL
425: THEN
426: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
427: l_return_status := OKC_API.G_RET_STS_ERROR;

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

422: l_return_status := OKC_API.G_RET_STS_ERROR;
423: ELSIF p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
424: p_rscv_rec.buy_or_sell IS NULL
425: THEN
426: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
427: l_return_status := OKC_API.G_RET_STS_ERROR;
428: ELSIF p_rscv_rec.start_date = OKC_API.G_MISS_DATE OR
429: p_rscv_rec.start_date IS NULL
430: THEN

Line 427: l_return_status := OKC_API.G_RET_STS_ERROR;

423: ELSIF p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR OR
424: p_rscv_rec.buy_or_sell IS NULL
425: THEN
426: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
427: l_return_status := OKC_API.G_RET_STS_ERROR;
428: ELSIF p_rscv_rec.start_date = OKC_API.G_MISS_DATE OR
429: p_rscv_rec.start_date IS NULL
430: THEN
431: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');

Line 428: ELSIF p_rscv_rec.start_date = OKC_API.G_MISS_DATE OR

424: p_rscv_rec.buy_or_sell IS NULL
425: THEN
426: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'buy_or_sell');
427: l_return_status := OKC_API.G_RET_STS_ERROR;
428: ELSIF p_rscv_rec.start_date = OKC_API.G_MISS_DATE OR
429: p_rscv_rec.start_date IS NULL
430: THEN
431: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
432: l_return_status := OKC_API.G_RET_STS_ERROR;

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

427: l_return_status := OKC_API.G_RET_STS_ERROR;
428: ELSIF p_rscv_rec.start_date = OKC_API.G_MISS_DATE OR
429: p_rscv_rec.start_date IS NULL
430: THEN
431: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
432: l_return_status := OKC_API.G_RET_STS_ERROR;
433: ELSIF p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
434: p_rscv_rec.JTOT_OBJECT_CODE IS NULL
435: THEN

Line 432: l_return_status := OKC_API.G_RET_STS_ERROR;

428: ELSIF p_rscv_rec.start_date = OKC_API.G_MISS_DATE OR
429: p_rscv_rec.start_date IS NULL
430: THEN
431: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
432: l_return_status := OKC_API.G_RET_STS_ERROR;
433: ELSIF p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
434: p_rscv_rec.JTOT_OBJECT_CODE IS NULL
435: THEN
436: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');

Line 433: ELSIF p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR

429: p_rscv_rec.start_date IS NULL
430: THEN
431: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'start_date');
432: l_return_status := OKC_API.G_RET_STS_ERROR;
433: ELSIF p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
434: p_rscv_rec.JTOT_OBJECT_CODE IS NULL
435: THEN
436: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');
437: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 436: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');

432: l_return_status := OKC_API.G_RET_STS_ERROR;
433: ELSIF p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
434: p_rscv_rec.JTOT_OBJECT_CODE IS NULL
435: THEN
436: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');
437: l_return_status := OKC_API.G_RET_STS_ERROR;
438: ELSIF p_rscv_rec.object_version_number = OKC_API.G_MISS_NUM OR
439: p_rscv_rec.object_version_number IS NULL
440: THEN

Line 437: l_return_status := OKC_API.G_RET_STS_ERROR;

433: ELSIF p_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR OR
434: p_rscv_rec.JTOT_OBJECT_CODE IS NULL
435: THEN
436: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');
437: l_return_status := OKC_API.G_RET_STS_ERROR;
438: ELSIF p_rscv_rec.object_version_number = OKC_API.G_MISS_NUM OR
439: p_rscv_rec.object_version_number IS NULL
440: THEN
441: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');

Line 438: ELSIF p_rscv_rec.object_version_number = OKC_API.G_MISS_NUM OR

434: p_rscv_rec.JTOT_OBJECT_CODE IS NULL
435: THEN
436: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'JTOT_OBJECT_CODE');
437: l_return_status := OKC_API.G_RET_STS_ERROR;
438: ELSIF p_rscv_rec.object_version_number = OKC_API.G_MISS_NUM OR
439: p_rscv_rec.object_version_number IS NULL
440: THEN
441: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
442: l_return_status := OKC_API.G_RET_STS_ERROR;

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

437: l_return_status := OKC_API.G_RET_STS_ERROR;
438: ELSIF p_rscv_rec.object_version_number = OKC_API.G_MISS_NUM OR
439: p_rscv_rec.object_version_number IS NULL
440: THEN
441: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
442: l_return_status := OKC_API.G_RET_STS_ERROR;
443: END IF;
444: RETURN(l_return_status);
445: END Validate_Attributes;

Line 442: l_return_status := OKC_API.G_RET_STS_ERROR;

438: ELSIF p_rscv_rec.object_version_number = OKC_API.G_MISS_NUM OR
439: p_rscv_rec.object_version_number IS NULL
440: THEN
441: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
442: l_return_status := OKC_API.G_RET_STS_ERROR;
443: END IF;
444: RETURN(l_return_status);
445: END Validate_Attributes;
446: /*+++++++++++++Start of hand code +++++++++++++++++*/

Line 447: x_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;

443: END IF;
444: RETURN(l_return_status);
445: END Validate_Attributes;
446: /*+++++++++++++Start of hand code +++++++++++++++++*/
447: x_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;
448: BEGIN
449: -- call each column-level validation
450: validate_rle_code(x_return_status => l_return_status,
451: p_rscv_rec => p_rscv_rec);

Line 452: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

448: BEGIN
449: -- call each column-level validation
450: validate_rle_code(x_return_status => l_return_status,
451: p_rscv_rec => p_rscv_rec);
452: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
453: return OKC_API.G_RET_STS_UNEXP_ERROR;
454: end if;
455: if (l_return_status = OKC_API.G_RET_STS_ERROR
456: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

Line 453: return OKC_API.G_RET_STS_UNEXP_ERROR;

449: -- call each column-level validation
450: validate_rle_code(x_return_status => l_return_status,
451: p_rscv_rec => p_rscv_rec);
452: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
453: return OKC_API.G_RET_STS_UNEXP_ERROR;
454: end if;
455: if (l_return_status = OKC_API.G_RET_STS_ERROR
456: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
457: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 455: if (l_return_status = OKC_API.G_RET_STS_ERROR

451: p_rscv_rec => p_rscv_rec);
452: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
453: return OKC_API.G_RET_STS_UNEXP_ERROR;
454: end if;
455: if (l_return_status = OKC_API.G_RET_STS_ERROR
456: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
457: x_return_status := OKC_API.G_RET_STS_ERROR;
458: end if;
459: --

Line 456: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

452: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
453: return OKC_API.G_RET_STS_UNEXP_ERROR;
454: end if;
455: if (l_return_status = OKC_API.G_RET_STS_ERROR
456: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
457: x_return_status := OKC_API.G_RET_STS_ERROR;
458: end if;
459: --
460: validate_buy_or_sell(x_return_status => l_return_status,

Line 457: x_return_status := OKC_API.G_RET_STS_ERROR;

453: return OKC_API.G_RET_STS_UNEXP_ERROR;
454: end if;
455: if (l_return_status = OKC_API.G_RET_STS_ERROR
456: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
457: x_return_status := OKC_API.G_RET_STS_ERROR;
458: end if;
459: --
460: validate_buy_or_sell(x_return_status => l_return_status,
461: p_rscv_rec => p_rscv_rec);

Line 462: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

458: end if;
459: --
460: validate_buy_or_sell(x_return_status => l_return_status,
461: p_rscv_rec => p_rscv_rec);
462: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
463: return OKC_API.G_RET_STS_UNEXP_ERROR;
464: end if;
465: if (l_return_status = OKC_API.G_RET_STS_ERROR
466: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

Line 463: return OKC_API.G_RET_STS_UNEXP_ERROR;

459: --
460: validate_buy_or_sell(x_return_status => l_return_status,
461: p_rscv_rec => p_rscv_rec);
462: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
463: return OKC_API.G_RET_STS_UNEXP_ERROR;
464: end if;
465: if (l_return_status = OKC_API.G_RET_STS_ERROR
466: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
467: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 465: if (l_return_status = OKC_API.G_RET_STS_ERROR

461: p_rscv_rec => p_rscv_rec);
462: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
463: return OKC_API.G_RET_STS_UNEXP_ERROR;
464: end if;
465: if (l_return_status = OKC_API.G_RET_STS_ERROR
466: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
467: x_return_status := OKC_API.G_RET_STS_ERROR;
468: end if;
469: --

Line 466: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

462: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
463: return OKC_API.G_RET_STS_UNEXP_ERROR;
464: end if;
465: if (l_return_status = OKC_API.G_RET_STS_ERROR
466: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
467: x_return_status := OKC_API.G_RET_STS_ERROR;
468: end if;
469: --
470: validate_start_date(x_return_status => l_return_status,

Line 467: x_return_status := OKC_API.G_RET_STS_ERROR;

463: return OKC_API.G_RET_STS_UNEXP_ERROR;
464: end if;
465: if (l_return_status = OKC_API.G_RET_STS_ERROR
466: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
467: x_return_status := OKC_API.G_RET_STS_ERROR;
468: end if;
469: --
470: validate_start_date(x_return_status => l_return_status,
471: p_rscv_rec => p_rscv_rec);

Line 472: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

468: end if;
469: --
470: validate_start_date(x_return_status => l_return_status,
471: p_rscv_rec => p_rscv_rec);
472: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
473: return OKC_API.G_RET_STS_UNEXP_ERROR;
474: end if;
475: if (l_return_status = OKC_API.G_RET_STS_ERROR
476: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

Line 473: return OKC_API.G_RET_STS_UNEXP_ERROR;

469: --
470: validate_start_date(x_return_status => l_return_status,
471: p_rscv_rec => p_rscv_rec);
472: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
473: return OKC_API.G_RET_STS_UNEXP_ERROR;
474: end if;
475: if (l_return_status = OKC_API.G_RET_STS_ERROR
476: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
477: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 475: if (l_return_status = OKC_API.G_RET_STS_ERROR

471: p_rscv_rec => p_rscv_rec);
472: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
473: return OKC_API.G_RET_STS_UNEXP_ERROR;
474: end if;
475: if (l_return_status = OKC_API.G_RET_STS_ERROR
476: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
477: x_return_status := OKC_API.G_RET_STS_ERROR;
478: end if;
479: --

Line 476: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

472: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
473: return OKC_API.G_RET_STS_UNEXP_ERROR;
474: end if;
475: if (l_return_status = OKC_API.G_RET_STS_ERROR
476: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
477: x_return_status := OKC_API.G_RET_STS_ERROR;
478: end if;
479: --
480: validate_JTOT_OBJECT_CODE(x_return_status => l_return_status,

Line 477: x_return_status := OKC_API.G_RET_STS_ERROR;

473: return OKC_API.G_RET_STS_UNEXP_ERROR;
474: end if;
475: if (l_return_status = OKC_API.G_RET_STS_ERROR
476: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
477: x_return_status := OKC_API.G_RET_STS_ERROR;
478: end if;
479: --
480: validate_JTOT_OBJECT_CODE(x_return_status => l_return_status,
481: p_rscv_rec => p_rscv_rec);

Line 482: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

478: end if;
479: --
480: validate_JTOT_OBJECT_CODE(x_return_status => l_return_status,
481: p_rscv_rec => p_rscv_rec);
482: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
483: return OKC_API.G_RET_STS_UNEXP_ERROR;
484: end if;
485: if (l_return_status = OKC_API.G_RET_STS_ERROR
486: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

Line 483: return OKC_API.G_RET_STS_UNEXP_ERROR;

479: --
480: validate_JTOT_OBJECT_CODE(x_return_status => l_return_status,
481: p_rscv_rec => p_rscv_rec);
482: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
483: return OKC_API.G_RET_STS_UNEXP_ERROR;
484: end if;
485: if (l_return_status = OKC_API.G_RET_STS_ERROR
486: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
487: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 485: if (l_return_status = OKC_API.G_RET_STS_ERROR

481: p_rscv_rec => p_rscv_rec);
482: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
483: return OKC_API.G_RET_STS_UNEXP_ERROR;
484: end if;
485: if (l_return_status = OKC_API.G_RET_STS_ERROR
486: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
487: x_return_status := OKC_API.G_RET_STS_ERROR;
488: end if;
489: --

Line 486: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

482: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
483: return OKC_API.G_RET_STS_UNEXP_ERROR;
484: end if;
485: if (l_return_status = OKC_API.G_RET_STS_ERROR
486: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
487: x_return_status := OKC_API.G_RET_STS_ERROR;
488: end if;
489: --
490: validate_ACCESS_LEVEL(x_return_status => l_return_status,

Line 487: x_return_status := OKC_API.G_RET_STS_ERROR;

483: return OKC_API.G_RET_STS_UNEXP_ERROR;
484: end if;
485: if (l_return_status = OKC_API.G_RET_STS_ERROR
486: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
487: x_return_status := OKC_API.G_RET_STS_ERROR;
488: end if;
489: --
490: validate_ACCESS_LEVEL(x_return_status => l_return_status,
491: p_rscv_rec => p_rscv_rec);

Line 492: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

488: end if;
489: --
490: validate_ACCESS_LEVEL(x_return_status => l_return_status,
491: p_rscv_rec => p_rscv_rec);
492: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
493: return OKC_API.G_RET_STS_UNEXP_ERROR;
494: end if;
495: if (l_return_status = OKC_API.G_RET_STS_ERROR
496: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

Line 493: return OKC_API.G_RET_STS_UNEXP_ERROR;

489: --
490: validate_ACCESS_LEVEL(x_return_status => l_return_status,
491: p_rscv_rec => p_rscv_rec);
492: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
493: return OKC_API.G_RET_STS_UNEXP_ERROR;
494: end if;
495: if (l_return_status = OKC_API.G_RET_STS_ERROR
496: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
497: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 495: if (l_return_status = OKC_API.G_RET_STS_ERROR

491: p_rscv_rec => p_rscv_rec);
492: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
493: return OKC_API.G_RET_STS_UNEXP_ERROR;
494: end if;
495: if (l_return_status = OKC_API.G_RET_STS_ERROR
496: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
497: x_return_status := OKC_API.G_RET_STS_ERROR;
498: end if;
499: return x_return_status;

Line 496: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

492: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
493: return OKC_API.G_RET_STS_UNEXP_ERROR;
494: end if;
495: if (l_return_status = OKC_API.G_RET_STS_ERROR
496: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
497: x_return_status := OKC_API.G_RET_STS_ERROR;
498: end if;
499: return x_return_status;
500: exception

Line 497: x_return_status := OKC_API.G_RET_STS_ERROR;

493: return OKC_API.G_RET_STS_UNEXP_ERROR;
494: end if;
495: if (l_return_status = OKC_API.G_RET_STS_ERROR
496: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
497: x_return_status := OKC_API.G_RET_STS_ERROR;
498: end if;
499: return x_return_status;
500: exception
501: when OTHERS then

Line 503: OKC_API.set_message(p_app_name => g_app_name,

499: return x_return_status;
500: exception
501: when OTHERS then
502: -- store SQL error message on message stack for caller
503: OKC_API.set_message(p_app_name => g_app_name,
504: p_msg_name => g_unexpected_error,
505: p_token1 => g_sqlcode_token,
506: p_token1_value => sqlcode,
507: p_token2 => g_sqlerrm_token,

Line 509: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

505: p_token1 => g_sqlcode_token,
506: p_token1_value => sqlcode,
507: p_token2 => g_sqlerrm_token,
508: p_token2_value => sqlerrm);
509: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
510: return x_return_status;
511: END Validate_Attributes;
512:
513: /*+++++++++++++End of hand code +++++++++++++++++++*/

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

523: --+++++++++++++++Start handcode +++++++++++++++++++++++++++++++++++
524: ,p_mode IN varchar2 default 'UPDATE' -- or 'INSERT'
525: --+++++++++++++++End handcode +++++++++++++++++++++++++++++++++++
526: ) RETURN VARCHAR2 IS
527: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
528: /*-------------Commented in favor of hand code------
529: BEGIN
530: RETURN (l_return_status);
531: END Validate_Record;

Line 534: x_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;

530: RETURN (l_return_status);
531: END Validate_Record;
532: ---------------End of the commented code-----------*/
533: /*+++++++++++++Start of hand code +++++++++++++++++*/
534: x_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;
535: cursor pk_csr is
536: select '!' from okc_role_sources
537: where rle_code = p_rscv_rec.rle_code
538: and buy_or_sell = p_rscv_rec.buy_or_sell

Line 544: if (p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR

540: l_dummy varchar2(1) := '?';
541: BEGIN
542: if (p_mode = 'INSERT') then
543: --
544: if (p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR
545: and p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR
546: and p_rscv_rec.start_date = OKC_API.G_MISS_DATE )
547: then
548: return x_return_status;

Line 545: and p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR

541: BEGIN
542: if (p_mode = 'INSERT') then
543: --
544: if (p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR
545: and p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR
546: and p_rscv_rec.start_date = OKC_API.G_MISS_DATE )
547: then
548: return x_return_status;
549: end if;

Line 546: and p_rscv_rec.start_date = OKC_API.G_MISS_DATE )

542: if (p_mode = 'INSERT') then
543: --
544: if (p_rscv_rec.rle_code = OKC_API.G_MISS_CHAR
545: and p_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR
546: and p_rscv_rec.start_date = OKC_API.G_MISS_DATE )
547: then
548: return x_return_status;
549: end if;
550: --

Line 560: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'RLE_CODE, BUY_OR_SELL, START_DATE');

556: then
557: return x_return_status;
558: end if;
559: --
560: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'RLE_CODE, BUY_OR_SELL, START_DATE');
561: return OKC_API.G_RET_STS_ERROR;
562: else -- other mode than INSERT
563: return x_return_status;
564: end if;

Line 561: return OKC_API.G_RET_STS_ERROR;

557: return x_return_status;
558: end if;
559: --
560: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'RLE_CODE, BUY_OR_SELL, START_DATE');
561: return OKC_API.G_RET_STS_ERROR;
562: else -- other mode than INSERT
563: return x_return_status;
564: end if;
565: exception

Line 568: OKC_API.set_message(p_app_name => g_app_name,

564: end if;
565: exception
566: when OTHERS then
567: -- store SQL error message on message stack for caller
568: OKC_API.set_message(p_app_name => g_app_name,
569: p_msg_name => g_unexpected_error,
570: p_token1 => g_sqlcode_token,
571: p_token1_value => sqlcode,
572: p_token2 => g_sqlerrm_token,

Line 574: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

570: p_token1 => g_sqlcode_token,
571: p_token1_value => sqlcode,
572: p_token2 => g_sqlerrm_token,
573: p_token2_value => sqlerrm);
574: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
575: return x_return_status;
576: END Validate_Record;
577: /*+++++++++++++End of hand code +++++++++++++++++*/
578:

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

631: p_rscv_rec IN rscv_rec_type) IS
632:
633: l_api_version CONSTANT NUMBER := 1;
634: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_row';
635: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
636: l_rscv_rec rscv_rec_type := p_rscv_rec;
637: l_rsc_rec rsc_rec_type;
638: BEGIN
639: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

635: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
636: l_rscv_rec rscv_rec_type := p_rscv_rec;
637: l_rsc_rec rsc_rec_type;
638: BEGIN
639: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
640: G_PKG_NAME,
641: p_init_msg_list,
642: l_api_version,
643: p_api_version,

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

642: l_api_version,
643: p_api_version,
644: '_PVT',
645: x_return_status);
646: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
647: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
648: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
649: RAISE OKC_API.G_EXCEPTION_ERROR;
650: END IF;

Line 647: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

643: p_api_version,
644: '_PVT',
645: x_return_status);
646: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
647: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
648: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
649: RAISE OKC_API.G_EXCEPTION_ERROR;
650: END IF;
651: --- Validate all non-missing attributes (Item Level Validation)

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

644: '_PVT',
645: x_return_status);
646: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
647: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
648: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
649: RAISE OKC_API.G_EXCEPTION_ERROR;
650: END IF;
651: --- Validate all non-missing attributes (Item Level Validation)
652: l_return_status := Validate_Attributes(l_rscv_rec);

Line 649: RAISE OKC_API.G_EXCEPTION_ERROR;

645: x_return_status);
646: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
647: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
648: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
649: RAISE OKC_API.G_EXCEPTION_ERROR;
650: END IF;
651: --- Validate all non-missing attributes (Item Level Validation)
652: l_return_status := Validate_Attributes(l_rscv_rec);
653: --- If any errors happen abort API

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

650: END IF;
651: --- Validate all non-missing attributes (Item Level Validation)
652: l_return_status := Validate_Attributes(l_rscv_rec);
653: --- If any errors happen abort API
654: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
655: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
656: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
657: RAISE OKC_API.G_EXCEPTION_ERROR;
658: END IF;

Line 655: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

651: --- Validate all non-missing attributes (Item Level Validation)
652: l_return_status := Validate_Attributes(l_rscv_rec);
653: --- If any errors happen abort API
654: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
655: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
656: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
657: RAISE OKC_API.G_EXCEPTION_ERROR;
658: END IF;
659: l_return_status := Validate_Record(l_rscv_rec);

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

652: l_return_status := Validate_Attributes(l_rscv_rec);
653: --- If any errors happen abort API
654: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
655: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
656: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
657: RAISE OKC_API.G_EXCEPTION_ERROR;
658: END IF;
659: l_return_status := Validate_Record(l_rscv_rec);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 657: RAISE OKC_API.G_EXCEPTION_ERROR;

653: --- If any errors happen abort API
654: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
655: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
656: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
657: RAISE OKC_API.G_EXCEPTION_ERROR;
658: END IF;
659: l_return_status := Validate_Record(l_rscv_rec);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

656: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
657: RAISE OKC_API.G_EXCEPTION_ERROR;
658: END IF;
659: l_return_status := Validate_Record(l_rscv_rec);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: RAISE OKC_API.G_EXCEPTION_ERROR;
664: END IF;

Line 661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

657: RAISE OKC_API.G_EXCEPTION_ERROR;
658: END IF;
659: l_return_status := Validate_Record(l_rscv_rec);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: RAISE OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

658: END IF;
659: l_return_status := Validate_Record(l_rscv_rec);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: RAISE OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
666: EXCEPTION

Line 663: RAISE OKC_API.G_EXCEPTION_ERROR;

659: l_return_status := Validate_Record(l_rscv_rec);
660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: RAISE OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
666: EXCEPTION
667: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
663: RAISE OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
666: EXCEPTION
667: WHEN OKC_API.G_EXCEPTION_ERROR THEN
668: x_return_status := OKC_API.HANDLE_EXCEPTIONS
669: (

Line 667: WHEN OKC_API.G_EXCEPTION_ERROR THEN

663: RAISE OKC_API.G_EXCEPTION_ERROR;
664: END IF;
665: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
666: EXCEPTION
667: WHEN OKC_API.G_EXCEPTION_ERROR THEN
668: x_return_status := OKC_API.HANDLE_EXCEPTIONS
669: (
670: l_api_name,
671: G_PKG_NAME,

Line 668: x_return_status := OKC_API.HANDLE_EXCEPTIONS

664: END IF;
665: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
666: EXCEPTION
667: WHEN OKC_API.G_EXCEPTION_ERROR THEN
668: x_return_status := OKC_API.HANDLE_EXCEPTIONS
669: (
670: l_api_name,
671: G_PKG_NAME,
672: 'OKC_API.G_RET_STS_ERROR',

Line 672: 'OKC_API.G_RET_STS_ERROR',

668: x_return_status := OKC_API.HANDLE_EXCEPTIONS
669: (
670: l_api_name,
671: G_PKG_NAME,
672: 'OKC_API.G_RET_STS_ERROR',
673: x_msg_count,
674: x_msg_data,
675: '_PVT'
676: );

Line 677: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

673: x_msg_count,
674: x_msg_data,
675: '_PVT'
676: );
677: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
678: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
679: (
680: l_api_name,
681: G_PKG_NAME,

Line 678: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

674: x_msg_data,
675: '_PVT'
676: );
677: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
678: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
679: (
680: l_api_name,
681: G_PKG_NAME,
682: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 682: 'OKC_API.G_RET_STS_UNEXP_ERROR',

678: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
679: (
680: l_api_name,
681: G_PKG_NAME,
682: 'OKC_API.G_RET_STS_UNEXP_ERROR',
683: x_msg_count,
684: x_msg_data,
685: '_PVT'
686: );

Line 688: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

684: x_msg_data,
685: '_PVT'
686: );
687: WHEN OTHERS THEN
688: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
689: (
690: l_api_name,
691: G_PKG_NAME,
692: 'OTHERS',

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

707: p_rscv_tbl IN rscv_tbl_type) IS
708:
709: l_api_version CONSTANT NUMBER := 1;
710: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
711: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
712: i NUMBER := 0;
713: BEGIN
714: OKC_API.init_msg_list(p_init_msg_list);
715: -- Make sure PL/SQL table has records in it before passing

Line 714: OKC_API.init_msg_list(p_init_msg_list);

710: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
711: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
712: i NUMBER := 0;
713: BEGIN
714: OKC_API.init_msg_list(p_init_msg_list);
715: -- Make sure PL/SQL table has records in it before passing
716: IF (p_rscv_tbl.COUNT > 0) THEN
717: i := p_rscv_tbl.FIRST;
718: LOOP

Line 721: p_init_msg_list => OKC_API.G_FALSE,

717: i := p_rscv_tbl.FIRST;
718: LOOP
719: validate_row (
720: p_api_version => p_api_version,
721: p_init_msg_list => OKC_API.G_FALSE,
722: x_return_status => x_return_status,
723: x_msg_count => x_msg_count,
724: x_msg_data => x_msg_data,
725: p_rscv_rec => p_rscv_tbl(i));

Line 731: WHEN OKC_API.G_EXCEPTION_ERROR THEN

727: i := p_rscv_tbl.NEXT(i);
728: END LOOP;
729: END IF;
730: EXCEPTION
731: WHEN OKC_API.G_EXCEPTION_ERROR THEN
732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (
734: l_api_name,
735: G_PKG_NAME,

Line 732: x_return_status := OKC_API.HANDLE_EXCEPTIONS

728: END LOOP;
729: END IF;
730: EXCEPTION
731: WHEN OKC_API.G_EXCEPTION_ERROR THEN
732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (
734: l_api_name,
735: G_PKG_NAME,
736: 'OKC_API.G_RET_STS_ERROR',

Line 736: 'OKC_API.G_RET_STS_ERROR',

732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (
734: l_api_name,
735: G_PKG_NAME,
736: 'OKC_API.G_RET_STS_ERROR',
737: x_msg_count,
738: x_msg_data,
739: '_PVT'
740: );

Line 741: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

737: x_msg_count,
738: x_msg_data,
739: '_PVT'
740: );
741: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
743: (
744: l_api_name,
745: G_PKG_NAME,

Line 742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

738: x_msg_data,
739: '_PVT'
740: );
741: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
743: (
744: l_api_name,
745: G_PKG_NAME,
746: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 746: 'OKC_API.G_RET_STS_UNEXP_ERROR',

742: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
743: (
744: l_api_name,
745: G_PKG_NAME,
746: 'OKC_API.G_RET_STS_UNEXP_ERROR',
747: x_msg_count,
748: x_msg_data,
749: '_PVT'
750: );

Line 752: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

748: x_msg_data,
749: '_PVT'
750: );
751: WHEN OTHERS THEN
752: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
753: (
754: l_api_name,
755: G_PKG_NAME,
756: 'OTHERS',

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

775: x_rsc_rec OUT NOCOPY rsc_rec_type) IS
776:
777: l_api_version CONSTANT NUMBER := 1;
778: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_insert_row';
779: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
780: l_rsc_rec rsc_rec_type := p_rsc_rec;
781: l_def_rsc_rec rsc_rec_type;
782: -----------------------------------------
783: -- Set_Attributes for:OKC_ROLE_SOURCES --

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

785: FUNCTION Set_Attributes (
786: p_rsc_rec IN rsc_rec_type,
787: x_rsc_rec OUT NOCOPY rsc_rec_type
788: ) RETURN VARCHAR2 IS
789: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
790: BEGIN
791: x_rsc_rec := p_rsc_rec;
792: RETURN(l_return_status);
793: END Set_Attributes;

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

791: x_rsc_rec := p_rsc_rec;
792: RETURN(l_return_status);
793: END Set_Attributes;
794: BEGIN
795: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
796: p_init_msg_list,
797: '_PVT',
798: x_return_status);
799: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

795: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
796: p_init_msg_list,
797: '_PVT',
798: x_return_status);
799: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
801: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
802: RAISE OKC_API.G_EXCEPTION_ERROR;
803: END IF;

Line 800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

796: p_init_msg_list,
797: '_PVT',
798: x_return_status);
799: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
801: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
802: RAISE OKC_API.G_EXCEPTION_ERROR;
803: END IF;
804: --- Setting item attributes

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

797: '_PVT',
798: x_return_status);
799: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
801: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
802: RAISE OKC_API.G_EXCEPTION_ERROR;
803: END IF;
804: --- Setting item attributes
805: l_return_status := Set_Attributes(

Line 802: RAISE OKC_API.G_EXCEPTION_ERROR;

798: x_return_status);
799: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
800: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
801: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
802: RAISE OKC_API.G_EXCEPTION_ERROR;
803: END IF;
804: --- Setting item attributes
805: l_return_status := Set_Attributes(
806: p_rsc_rec, -- IN

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

805: l_return_status := Set_Attributes(
806: p_rsc_rec, -- IN
807: l_rsc_rec); -- OUT
808: --- If any errors happen abort API
809: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
810: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
811: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
812: RAISE OKC_API.G_EXCEPTION_ERROR;
813: END IF;

Line 810: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

806: p_rsc_rec, -- IN
807: l_rsc_rec); -- OUT
808: --- If any errors happen abort API
809: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
810: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
811: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
812: RAISE OKC_API.G_EXCEPTION_ERROR;
813: END IF;
814: INSERT INTO OKC_ROLE_SOURCES(

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

807: l_rsc_rec); -- OUT
808: --- If any errors happen abort API
809: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
810: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
811: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
812: RAISE OKC_API.G_EXCEPTION_ERROR;
813: END IF;
814: INSERT INTO OKC_ROLE_SOURCES(
815: rle_code,

Line 812: RAISE OKC_API.G_EXCEPTION_ERROR;

808: --- If any errors happen abort API
809: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
810: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
811: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
812: RAISE OKC_API.G_EXCEPTION_ERROR;
813: END IF;
814: INSERT INTO OKC_ROLE_SOURCES(
815: rle_code,
816: buy_or_sell,

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

838: l_rsc_rec.last_update_login,
839: l_rsc_rec.access_level);
840: -- Set OUT values
841: x_rsc_rec := l_rsc_rec;
842: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
843: EXCEPTION
844: WHEN OKC_API.G_EXCEPTION_ERROR THEN
845: x_return_status := OKC_API.HANDLE_EXCEPTIONS
846: (

Line 844: WHEN OKC_API.G_EXCEPTION_ERROR THEN

840: -- Set OUT values
841: x_rsc_rec := l_rsc_rec;
842: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
843: EXCEPTION
844: WHEN OKC_API.G_EXCEPTION_ERROR THEN
845: x_return_status := OKC_API.HANDLE_EXCEPTIONS
846: (
847: l_api_name,
848: G_PKG_NAME,

Line 845: x_return_status := OKC_API.HANDLE_EXCEPTIONS

841: x_rsc_rec := l_rsc_rec;
842: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
843: EXCEPTION
844: WHEN OKC_API.G_EXCEPTION_ERROR THEN
845: x_return_status := OKC_API.HANDLE_EXCEPTIONS
846: (
847: l_api_name,
848: G_PKG_NAME,
849: 'OKC_API.G_RET_STS_ERROR',

Line 849: 'OKC_API.G_RET_STS_ERROR',

845: x_return_status := OKC_API.HANDLE_EXCEPTIONS
846: (
847: l_api_name,
848: G_PKG_NAME,
849: 'OKC_API.G_RET_STS_ERROR',
850: x_msg_count,
851: x_msg_data,
852: '_PVT'
853: );

Line 854: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

850: x_msg_count,
851: x_msg_data,
852: '_PVT'
853: );
854: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
855: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
856: (
857: l_api_name,
858: G_PKG_NAME,

Line 855: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

851: x_msg_data,
852: '_PVT'
853: );
854: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
855: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
856: (
857: l_api_name,
858: G_PKG_NAME,
859: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 859: 'OKC_API.G_RET_STS_UNEXP_ERROR',

855: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
856: (
857: l_api_name,
858: G_PKG_NAME,
859: 'OKC_API.G_RET_STS_UNEXP_ERROR',
860: x_msg_count,
861: x_msg_data,
862: '_PVT'
863: );

Line 865: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

861: x_msg_data,
862: '_PVT'
863: );
864: WHEN OTHERS THEN
865: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
866: (
867: l_api_name,
868: G_PKG_NAME,
869: 'OTHERS',

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

885: x_rscv_rec OUT NOCOPY rscv_rec_type) IS
886:
887: l_api_version CONSTANT NUMBER := 1;
888: l_api_name CONSTANT VARCHAR2(30) := 'V_insert_row';
889: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
890: l_rscv_rec rscv_rec_type;
891: l_def_rscv_rec rscv_rec_type;
892: l_rsc_rec rsc_rec_type;
893: lx_rsc_rec rsc_rec_type;

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

912: FUNCTION Set_Attributes (
913: p_rscv_rec IN rscv_rec_type,
914: x_rscv_rec OUT NOCOPY rscv_rec_type
915: ) RETURN VARCHAR2 IS
916: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
917: BEGIN
918: x_rscv_rec := p_rscv_rec;
919: x_rscv_rec.OBJECT_VERSION_NUMBER := 1;
920: RETURN(l_return_status);

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

919: x_rscv_rec.OBJECT_VERSION_NUMBER := 1;
920: RETURN(l_return_status);
921: END Set_Attributes;
922: BEGIN
923: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
924: G_PKG_NAME,
925: p_init_msg_list,
926: l_api_version,
927: p_api_version,

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

926: l_api_version,
927: p_api_version,
928: '_PVT',
929: x_return_status);
930: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
931: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
932: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
933: RAISE OKC_API.G_EXCEPTION_ERROR;
934: END IF;

Line 931: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

927: p_api_version,
928: '_PVT',
929: x_return_status);
930: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
931: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
932: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
933: RAISE OKC_API.G_EXCEPTION_ERROR;
934: END IF;
935: l_rscv_rec := null_out_defaults(p_rscv_rec);

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

928: '_PVT',
929: x_return_status);
930: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
931: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
932: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
933: RAISE OKC_API.G_EXCEPTION_ERROR;
934: END IF;
935: l_rscv_rec := null_out_defaults(p_rscv_rec);
936: --- Setting item attributes

Line 933: RAISE OKC_API.G_EXCEPTION_ERROR;

929: x_return_status);
930: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
931: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
932: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
933: RAISE OKC_API.G_EXCEPTION_ERROR;
934: END IF;
935: l_rscv_rec := null_out_defaults(p_rscv_rec);
936: --- Setting item attributes
937: l_return_status := Set_Attributes(

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

937: l_return_status := Set_Attributes(
938: l_rscv_rec, -- IN
939: l_def_rscv_rec); -- OUT
940: --- If any errors happen abort API
941: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;

Line 942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

938: l_rscv_rec, -- IN
939: l_def_rscv_rec); -- OUT
940: --- If any errors happen abort API
941: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;
946: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);

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

939: l_def_rscv_rec); -- OUT
940: --- If any errors happen abort API
941: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;
946: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);
947: --- Validate all non-missing attributes (Item Level Validation)

Line 944: RAISE OKC_API.G_EXCEPTION_ERROR;

940: --- If any errors happen abort API
941: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;
946: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);
947: --- Validate all non-missing attributes (Item Level Validation)
948: l_return_status := Validate_Attributes(l_def_rscv_rec);

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

946: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);
947: --- Validate all non-missing attributes (Item Level Validation)
948: l_return_status := Validate_Attributes(l_def_rscv_rec);
949: --- If any errors happen abort API
950: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_ERROR;
954: END IF;

Line 951: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

947: --- Validate all non-missing attributes (Item Level Validation)
948: l_return_status := Validate_Attributes(l_def_rscv_rec);
949: --- If any errors happen abort API
950: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_ERROR;
954: END IF;
955: /*------------------------commented in favor of hand code-----------

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

948: l_return_status := Validate_Attributes(l_def_rscv_rec);
949: --- If any errors happen abort API
950: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_ERROR;
954: END IF;
955: /*------------------------commented in favor of hand code-----------
956: l_return_status := Validate_Record(l_def_rscv_rec);

Line 953: RAISE OKC_API.G_EXCEPTION_ERROR;

949: --- If any errors happen abort API
950: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
951: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
952: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
953: RAISE OKC_API.G_EXCEPTION_ERROR;
954: END IF;
955: /*------------------------commented in favor of hand code-----------
956: l_return_status := Validate_Record(l_def_rscv_rec);
957: ------------------------commented in favor of hand code-----------*/

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

957: ------------------------commented in favor of hand code-----------*/
958: --++++++++++++++++++++++Hand code start+++++++++++++++++++++++++++++
959: l_return_status := Validate_Record(l_def_rscv_rec,'INSERT');
960: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;

Line 962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

958: --++++++++++++++++++++++Hand code start+++++++++++++++++++++++++++++
959: l_return_status := Validate_Record(l_def_rscv_rec,'INSERT');
960: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;
966: --------------------------------------

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

959: l_return_status := Validate_Record(l_def_rscv_rec,'INSERT');
960: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;
966: --------------------------------------
967: -- Move VIEW record to "Child" records

Line 964: RAISE OKC_API.G_EXCEPTION_ERROR;

960: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
961: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
962: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
963: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
964: RAISE OKC_API.G_EXCEPTION_ERROR;
965: END IF;
966: --------------------------------------
967: -- Move VIEW record to "Child" records
968: --------------------------------------

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

977: x_msg_data,
978: l_rsc_rec,
979: lx_rsc_rec
980: );
981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
984: RAISE OKC_API.G_EXCEPTION_ERROR;
985: END IF;

Line 982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

978: l_rsc_rec,
979: lx_rsc_rec
980: );
981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
984: RAISE OKC_API.G_EXCEPTION_ERROR;
985: END IF;
986: migrate(lx_rsc_rec, l_def_rscv_rec);

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

979: lx_rsc_rec
980: );
981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
984: RAISE OKC_API.G_EXCEPTION_ERROR;
985: END IF;
986: migrate(lx_rsc_rec, l_def_rscv_rec);
987: -- Set OUT values

Line 984: RAISE OKC_API.G_EXCEPTION_ERROR;

980: );
981: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
982: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
983: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
984: RAISE OKC_API.G_EXCEPTION_ERROR;
985: END IF;
986: migrate(lx_rsc_rec, l_def_rscv_rec);
987: -- Set OUT values
988: x_rscv_rec := l_def_rscv_rec;

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

985: END IF;
986: migrate(lx_rsc_rec, l_def_rscv_rec);
987: -- Set OUT values
988: x_rscv_rec := l_def_rscv_rec;
989: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
990: EXCEPTION
991: WHEN OKC_API.G_EXCEPTION_ERROR THEN
992: x_return_status := OKC_API.HANDLE_EXCEPTIONS
993: (

Line 991: WHEN OKC_API.G_EXCEPTION_ERROR THEN

987: -- Set OUT values
988: x_rscv_rec := l_def_rscv_rec;
989: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
990: EXCEPTION
991: WHEN OKC_API.G_EXCEPTION_ERROR THEN
992: x_return_status := OKC_API.HANDLE_EXCEPTIONS
993: (
994: l_api_name,
995: G_PKG_NAME,

Line 992: x_return_status := OKC_API.HANDLE_EXCEPTIONS

988: x_rscv_rec := l_def_rscv_rec;
989: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
990: EXCEPTION
991: WHEN OKC_API.G_EXCEPTION_ERROR THEN
992: x_return_status := OKC_API.HANDLE_EXCEPTIONS
993: (
994: l_api_name,
995: G_PKG_NAME,
996: 'OKC_API.G_RET_STS_ERROR',

Line 996: 'OKC_API.G_RET_STS_ERROR',

992: x_return_status := OKC_API.HANDLE_EXCEPTIONS
993: (
994: l_api_name,
995: G_PKG_NAME,
996: 'OKC_API.G_RET_STS_ERROR',
997: x_msg_count,
998: x_msg_data,
999: '_PVT'
1000: );

Line 1001: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

997: x_msg_count,
998: x_msg_data,
999: '_PVT'
1000: );
1001: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1002: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1003: (
1004: l_api_name,
1005: G_PKG_NAME,

Line 1002: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

998: x_msg_data,
999: '_PVT'
1000: );
1001: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1002: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1003: (
1004: l_api_name,
1005: G_PKG_NAME,
1006: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1006: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1002: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1003: (
1004: l_api_name,
1005: G_PKG_NAME,
1006: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1007: x_msg_count,
1008: x_msg_data,
1009: '_PVT'
1010: );

Line 1012: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1008: x_msg_data,
1009: '_PVT'
1010: );
1011: WHEN OTHERS THEN
1012: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1013: (
1014: l_api_name,
1015: G_PKG_NAME,
1016: 'OTHERS',

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

1032: x_rscv_tbl OUT NOCOPY rscv_tbl_type) IS
1033:
1034: l_api_version CONSTANT NUMBER := 1;
1035: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
1036: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1037: i NUMBER := 0;
1038: BEGIN
1039: OKC_API.init_msg_list(p_init_msg_list);
1040: -- Make sure PL/SQL table has records in it before passing

Line 1039: OKC_API.init_msg_list(p_init_msg_list);

1035: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
1036: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1037: i NUMBER := 0;
1038: BEGIN
1039: OKC_API.init_msg_list(p_init_msg_list);
1040: -- Make sure PL/SQL table has records in it before passing
1041: IF (p_rscv_tbl.COUNT > 0) THEN
1042: i := p_rscv_tbl.FIRST;
1043: LOOP

Line 1046: p_init_msg_list => OKC_API.G_FALSE,

1042: i := p_rscv_tbl.FIRST;
1043: LOOP
1044: insert_row (
1045: p_api_version => p_api_version,
1046: p_init_msg_list => OKC_API.G_FALSE,
1047: x_return_status => x_return_status,
1048: x_msg_count => x_msg_count,
1049: x_msg_data => x_msg_data,
1050: p_rscv_rec => p_rscv_tbl(i),

Line 1057: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1053: i := p_rscv_tbl.NEXT(i);
1054: END LOOP;
1055: END IF;
1056: EXCEPTION
1057: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1058: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1059: (
1060: l_api_name,
1061: G_PKG_NAME,

Line 1058: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1054: END LOOP;
1055: END IF;
1056: EXCEPTION
1057: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1058: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1059: (
1060: l_api_name,
1061: G_PKG_NAME,
1062: 'OKC_API.G_RET_STS_ERROR',

Line 1062: 'OKC_API.G_RET_STS_ERROR',

1058: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1059: (
1060: l_api_name,
1061: G_PKG_NAME,
1062: 'OKC_API.G_RET_STS_ERROR',
1063: x_msg_count,
1064: x_msg_data,
1065: '_PVT'
1066: );

Line 1067: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1063: x_msg_count,
1064: x_msg_data,
1065: '_PVT'
1066: );
1067: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1068: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1069: (
1070: l_api_name,
1071: G_PKG_NAME,

Line 1068: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1064: x_msg_data,
1065: '_PVT'
1066: );
1067: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1068: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1069: (
1070: l_api_name,
1071: G_PKG_NAME,
1072: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1072: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1068: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1069: (
1070: l_api_name,
1071: G_PKG_NAME,
1072: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1073: x_msg_count,
1074: x_msg_data,
1075: '_PVT'
1076: );

Line 1078: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1074: x_msg_data,
1075: '_PVT'
1076: );
1077: WHEN OTHERS THEN
1078: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1079: (
1080: l_api_name,
1081: G_PKG_NAME,
1082: 'OTHERS',

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

1117: AND BUY_OR_SELL = p_rsc_rec.buy_or_sell
1118: AND START_DATE = p_rsc_rec.start_date;
1119: l_api_version CONSTANT NUMBER := 1;
1120: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_lock_row';
1121: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1122: l_object_version_number OKC_ROLE_SOURCES.OBJECT_VERSION_NUMBER%TYPE;
1123: lc_object_version_number OKC_ROLE_SOURCES.OBJECT_VERSION_NUMBER%TYPE;
1124: l_row_notfound BOOLEAN := FALSE;
1125: lc_row_notfound BOOLEAN := FALSE;

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

1123: lc_object_version_number OKC_ROLE_SOURCES.OBJECT_VERSION_NUMBER%TYPE;
1124: l_row_notfound BOOLEAN := FALSE;
1125: lc_row_notfound BOOLEAN := FALSE;
1126: BEGIN
1127: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1128: p_init_msg_list,
1129: '_PVT',
1130: x_return_status);
1131: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1127: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1128: p_init_msg_list,
1129: '_PVT',
1130: x_return_status);
1131: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1132: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1133: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1134: RAISE OKC_API.G_EXCEPTION_ERROR;
1135: END IF;

Line 1132: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1128: p_init_msg_list,
1129: '_PVT',
1130: x_return_status);
1131: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1132: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1133: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1134: RAISE OKC_API.G_EXCEPTION_ERROR;
1135: END IF;
1136: BEGIN

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

1129: '_PVT',
1130: x_return_status);
1131: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1132: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1133: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1134: RAISE OKC_API.G_EXCEPTION_ERROR;
1135: END IF;
1136: BEGIN
1137: OPEN lock_csr(p_rsc_rec);

Line 1134: RAISE OKC_API.G_EXCEPTION_ERROR;

1130: x_return_status);
1131: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1132: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1133: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1134: RAISE OKC_API.G_EXCEPTION_ERROR;
1135: END IF;
1136: BEGIN
1137: OPEN lock_csr(p_rsc_rec);
1138: FETCH lock_csr INTO l_object_version_number;

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

1142: WHEN E_Resource_Busy THEN
1143: IF (lock_csr%ISOPEN) THEN
1144: CLOSE lock_csr;
1145: END IF;
1146: OKC_API.set_message(G_FND_APP,G_FORM_UNABLE_TO_RESERVE_REC);
1147: RAISE APP_EXCEPTIONS.RECORD_LOCK_EXCEPTION;
1148: END;
1149:
1150: IF ( l_row_notfound ) THEN

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

1153: lc_row_notfound := lchk_csr%NOTFOUND;
1154: CLOSE lchk_csr;
1155: END IF;
1156: IF (lc_row_notfound) THEN
1157: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1158: RAISE OKC_API.G_EXCEPTION_ERROR;
1159: ELSIF lc_object_version_number > p_rsc_rec.object_version_number THEN
1160: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1161: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1158: RAISE OKC_API.G_EXCEPTION_ERROR;

1154: CLOSE lchk_csr;
1155: END IF;
1156: IF (lc_row_notfound) THEN
1157: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1158: RAISE OKC_API.G_EXCEPTION_ERROR;
1159: ELSIF lc_object_version_number > p_rsc_rec.object_version_number THEN
1160: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1161: RAISE OKC_API.G_EXCEPTION_ERROR;
1162: ELSIF lc_object_version_number <> p_rsc_rec.object_version_number THEN

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

1156: IF (lc_row_notfound) THEN
1157: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1158: RAISE OKC_API.G_EXCEPTION_ERROR;
1159: ELSIF lc_object_version_number > p_rsc_rec.object_version_number THEN
1160: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1161: RAISE OKC_API.G_EXCEPTION_ERROR;
1162: ELSIF lc_object_version_number <> p_rsc_rec.object_version_number THEN
1163: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1164: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1161: RAISE OKC_API.G_EXCEPTION_ERROR;

1157: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1158: RAISE OKC_API.G_EXCEPTION_ERROR;
1159: ELSIF lc_object_version_number > p_rsc_rec.object_version_number THEN
1160: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1161: RAISE OKC_API.G_EXCEPTION_ERROR;
1162: ELSIF lc_object_version_number <> p_rsc_rec.object_version_number THEN
1163: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1164: RAISE OKC_API.G_EXCEPTION_ERROR;
1165: ELSIF lc_object_version_number = -1 THEN

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

1159: ELSIF lc_object_version_number > p_rsc_rec.object_version_number THEN
1160: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1161: RAISE OKC_API.G_EXCEPTION_ERROR;
1162: ELSIF lc_object_version_number <> p_rsc_rec.object_version_number THEN
1163: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1164: RAISE OKC_API.G_EXCEPTION_ERROR;
1165: ELSIF lc_object_version_number = -1 THEN
1166: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1167: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1164: RAISE OKC_API.G_EXCEPTION_ERROR;

1160: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1161: RAISE OKC_API.G_EXCEPTION_ERROR;
1162: ELSIF lc_object_version_number <> p_rsc_rec.object_version_number THEN
1163: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1164: RAISE OKC_API.G_EXCEPTION_ERROR;
1165: ELSIF lc_object_version_number = -1 THEN
1166: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1167: RAISE OKC_API.G_EXCEPTION_ERROR;
1168: END IF;

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

1162: ELSIF lc_object_version_number <> p_rsc_rec.object_version_number THEN
1163: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1164: RAISE OKC_API.G_EXCEPTION_ERROR;
1165: ELSIF lc_object_version_number = -1 THEN
1166: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1167: RAISE OKC_API.G_EXCEPTION_ERROR;
1168: END IF;
1169: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1170: EXCEPTION

Line 1167: RAISE OKC_API.G_EXCEPTION_ERROR;

1163: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1164: RAISE OKC_API.G_EXCEPTION_ERROR;
1165: ELSIF lc_object_version_number = -1 THEN
1166: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1167: RAISE OKC_API.G_EXCEPTION_ERROR;
1168: END IF;
1169: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1170: EXCEPTION
1171: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1165: ELSIF lc_object_version_number = -1 THEN
1166: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1167: RAISE OKC_API.G_EXCEPTION_ERROR;
1168: END IF;
1169: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1170: EXCEPTION
1171: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1172: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1173: (

Line 1171: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1167: RAISE OKC_API.G_EXCEPTION_ERROR;
1168: END IF;
1169: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1170: EXCEPTION
1171: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1172: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1173: (
1174: l_api_name,
1175: G_PKG_NAME,

Line 1172: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1168: END IF;
1169: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1170: EXCEPTION
1171: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1172: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1173: (
1174: l_api_name,
1175: G_PKG_NAME,
1176: 'OKC_API.G_RET_STS_ERROR',

Line 1176: 'OKC_API.G_RET_STS_ERROR',

1172: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1173: (
1174: l_api_name,
1175: G_PKG_NAME,
1176: 'OKC_API.G_RET_STS_ERROR',
1177: x_msg_count,
1178: x_msg_data,
1179: '_PVT'
1180: );

Line 1181: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1177: x_msg_count,
1178: x_msg_data,
1179: '_PVT'
1180: );
1181: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1182: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1183: (
1184: l_api_name,
1185: G_PKG_NAME,

Line 1182: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1178: x_msg_data,
1179: '_PVT'
1180: );
1181: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1182: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1183: (
1184: l_api_name,
1185: G_PKG_NAME,
1186: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1186: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1182: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1183: (
1184: l_api_name,
1185: G_PKG_NAME,
1186: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1187: x_msg_count,
1188: x_msg_data,
1189: '_PVT'
1190: );

Line 1192: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1188: x_msg_data,
1189: '_PVT'
1190: );
1191: WHEN OTHERS THEN
1192: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1193: (
1194: l_api_name,
1195: G_PKG_NAME,
1196: 'OTHERS',

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

1211: p_rscv_rec IN rscv_rec_type) IS
1212:
1213: l_api_version CONSTANT NUMBER := 1;
1214: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
1215: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1216: l_rsc_rec rsc_rec_type;
1217: BEGIN
1218: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1219: G_PKG_NAME,

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

1214: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
1215: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1216: l_rsc_rec rsc_rec_type;
1217: BEGIN
1218: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1219: G_PKG_NAME,
1220: p_init_msg_list,
1221: l_api_version,
1222: p_api_version,

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

1221: l_api_version,
1222: p_api_version,
1223: '_PVT',
1224: x_return_status);
1225: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1227: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1228: RAISE OKC_API.G_EXCEPTION_ERROR;
1229: END IF;

Line 1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1222: p_api_version,
1223: '_PVT',
1224: x_return_status);
1225: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1227: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1228: RAISE OKC_API.G_EXCEPTION_ERROR;
1229: END IF;
1230: --------------------------------------

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

1223: '_PVT',
1224: x_return_status);
1225: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1227: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1228: RAISE OKC_API.G_EXCEPTION_ERROR;
1229: END IF;
1230: --------------------------------------
1231: -- Move VIEW record to "Child" records

Line 1228: RAISE OKC_API.G_EXCEPTION_ERROR;

1224: x_return_status);
1225: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1227: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1228: RAISE OKC_API.G_EXCEPTION_ERROR;
1229: END IF;
1230: --------------------------------------
1231: -- Move VIEW record to "Child" records
1232: --------------------------------------

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

1240: x_msg_count,
1241: x_msg_data,
1242: l_rsc_rec
1243: );
1244: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1245: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1246: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1247: RAISE OKC_API.G_EXCEPTION_ERROR;
1248: END IF;

Line 1245: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1241: x_msg_data,
1242: l_rsc_rec
1243: );
1244: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1245: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1246: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1247: RAISE OKC_API.G_EXCEPTION_ERROR;
1248: END IF;
1249: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1242: l_rsc_rec
1243: );
1244: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1245: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1246: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1247: RAISE OKC_API.G_EXCEPTION_ERROR;
1248: END IF;
1249: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1250: EXCEPTION

Line 1247: RAISE OKC_API.G_EXCEPTION_ERROR;

1243: );
1244: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1245: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1246: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1247: RAISE OKC_API.G_EXCEPTION_ERROR;
1248: END IF;
1249: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1250: EXCEPTION
1251: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1245: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1246: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1247: RAISE OKC_API.G_EXCEPTION_ERROR;
1248: END IF;
1249: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1250: EXCEPTION
1251: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1252: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1253: (

Line 1251: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1247: RAISE OKC_API.G_EXCEPTION_ERROR;
1248: END IF;
1249: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1250: EXCEPTION
1251: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1252: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1253: (
1254: l_api_name,
1255: G_PKG_NAME,

Line 1252: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1248: END IF;
1249: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1250: EXCEPTION
1251: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1252: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1253: (
1254: l_api_name,
1255: G_PKG_NAME,
1256: 'OKC_API.G_RET_STS_ERROR',

Line 1256: 'OKC_API.G_RET_STS_ERROR',

1252: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1253: (
1254: l_api_name,
1255: G_PKG_NAME,
1256: 'OKC_API.G_RET_STS_ERROR',
1257: x_msg_count,
1258: x_msg_data,
1259: '_PVT'
1260: );

Line 1261: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1257: x_msg_count,
1258: x_msg_data,
1259: '_PVT'
1260: );
1261: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1262: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1263: (
1264: l_api_name,
1265: G_PKG_NAME,

Line 1262: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1258: x_msg_data,
1259: '_PVT'
1260: );
1261: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1262: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1263: (
1264: l_api_name,
1265: G_PKG_NAME,
1266: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1266: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1262: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1263: (
1264: l_api_name,
1265: G_PKG_NAME,
1266: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1267: x_msg_count,
1268: x_msg_data,
1269: '_PVT'
1270: );

Line 1272: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1268: x_msg_data,
1269: '_PVT'
1270: );
1271: WHEN OTHERS THEN
1272: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1273: (
1274: l_api_name,
1275: G_PKG_NAME,
1276: 'OTHERS',

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

1291: p_rscv_tbl IN rscv_tbl_type) IS
1292:
1293: l_api_version CONSTANT NUMBER := 1;
1294: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
1295: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1296: i NUMBER := 0;
1297: BEGIN
1298: OKC_API.init_msg_list(p_init_msg_list);
1299: -- Make sure PL/SQL table has records in it before passing

Line 1298: OKC_API.init_msg_list(p_init_msg_list);

1294: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
1295: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1296: i NUMBER := 0;
1297: BEGIN
1298: OKC_API.init_msg_list(p_init_msg_list);
1299: -- Make sure PL/SQL table has records in it before passing
1300: IF (p_rscv_tbl.COUNT > 0) THEN
1301: i := p_rscv_tbl.FIRST;
1302: LOOP

Line 1305: p_init_msg_list => OKC_API.G_FALSE,

1301: i := p_rscv_tbl.FIRST;
1302: LOOP
1303: lock_row (
1304: p_api_version => p_api_version,
1305: p_init_msg_list => OKC_API.G_FALSE,
1306: x_return_status => x_return_status,
1307: x_msg_count => x_msg_count,
1308: x_msg_data => x_msg_data,
1309: p_rscv_rec => p_rscv_tbl(i));

Line 1315: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1311: i := p_rscv_tbl.NEXT(i);
1312: END LOOP;
1313: END IF;
1314: EXCEPTION
1315: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1317: (
1318: l_api_name,
1319: G_PKG_NAME,

Line 1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1312: END LOOP;
1313: END IF;
1314: EXCEPTION
1315: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1317: (
1318: l_api_name,
1319: G_PKG_NAME,
1320: 'OKC_API.G_RET_STS_ERROR',

Line 1320: 'OKC_API.G_RET_STS_ERROR',

1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1317: (
1318: l_api_name,
1319: G_PKG_NAME,
1320: 'OKC_API.G_RET_STS_ERROR',
1321: x_msg_count,
1322: x_msg_data,
1323: '_PVT'
1324: );

Line 1325: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1321: x_msg_count,
1322: x_msg_data,
1323: '_PVT'
1324: );
1325: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1326: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1327: (
1328: l_api_name,
1329: G_PKG_NAME,

Line 1326: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1322: x_msg_data,
1323: '_PVT'
1324: );
1325: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1326: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1327: (
1328: l_api_name,
1329: G_PKG_NAME,
1330: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1330: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1326: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1327: (
1328: l_api_name,
1329: G_PKG_NAME,
1330: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1331: x_msg_count,
1332: x_msg_data,
1333: '_PVT'
1334: );

Line 1336: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1332: x_msg_data,
1333: '_PVT'
1334: );
1335: WHEN OTHERS THEN
1336: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1337: (
1338: l_api_name,
1339: G_PKG_NAME,
1340: 'OTHERS',

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

1359: x_rsc_rec OUT NOCOPY rsc_rec_type) IS
1360:
1361: l_api_version CONSTANT NUMBER := 1;
1362: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_update_row';
1363: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1364: l_rsc_rec rsc_rec_type := p_rsc_rec;
1365: l_def_rsc_rec rsc_rec_type;
1366: l_row_notfound BOOLEAN := TRUE;
1367: ----------------------------------

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

1372: x_rsc_rec OUT NOCOPY rsc_rec_type
1373: ) RETURN VARCHAR2 IS
1374: l_rsc_rec rsc_rec_type;
1375: l_row_notfound BOOLEAN := TRUE;
1376: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1377: BEGIN
1378: x_rsc_rec := p_rsc_rec;
1379: -- Get current database values
1380: l_rsc_rec := get_rec(p_rsc_rec, l_row_notfound);

Line 1382: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1378: x_rsc_rec := p_rsc_rec;
1379: -- Get current database values
1380: l_rsc_rec := get_rec(p_rsc_rec, l_row_notfound);
1381: IF (l_row_notfound) THEN
1382: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1383: END IF;
1384: IF (x_rsc_rec.rle_code = OKC_API.G_MISS_CHAR)
1385: THEN
1386: x_rsc_rec.rle_code := l_rsc_rec.rle_code;

Line 1384: IF (x_rsc_rec.rle_code = OKC_API.G_MISS_CHAR)

1380: l_rsc_rec := get_rec(p_rsc_rec, l_row_notfound);
1381: IF (l_row_notfound) THEN
1382: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1383: END IF;
1384: IF (x_rsc_rec.rle_code = OKC_API.G_MISS_CHAR)
1385: THEN
1386: x_rsc_rec.rle_code := l_rsc_rec.rle_code;
1387: END IF;
1388: IF (x_rsc_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

Line 1388: IF (x_rsc_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

1384: IF (x_rsc_rec.rle_code = OKC_API.G_MISS_CHAR)
1385: THEN
1386: x_rsc_rec.rle_code := l_rsc_rec.rle_code;
1387: END IF;
1388: IF (x_rsc_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
1389: THEN
1390: x_rsc_rec.buy_or_sell := l_rsc_rec.buy_or_sell;
1391: END IF;
1392: IF (x_rsc_rec.start_date = OKC_API.G_MISS_DATE)

Line 1392: IF (x_rsc_rec.start_date = OKC_API.G_MISS_DATE)

1388: IF (x_rsc_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
1389: THEN
1390: x_rsc_rec.buy_or_sell := l_rsc_rec.buy_or_sell;
1391: END IF;
1392: IF (x_rsc_rec.start_date = OKC_API.G_MISS_DATE)
1393: THEN
1394: x_rsc_rec.start_date := l_rsc_rec.start_date;
1395: END IF;
1396: IF (x_rsc_rec.end_date = OKC_API.G_MISS_DATE)

Line 1396: IF (x_rsc_rec.end_date = OKC_API.G_MISS_DATE)

1392: IF (x_rsc_rec.start_date = OKC_API.G_MISS_DATE)
1393: THEN
1394: x_rsc_rec.start_date := l_rsc_rec.start_date;
1395: END IF;
1396: IF (x_rsc_rec.end_date = OKC_API.G_MISS_DATE)
1397: THEN
1398: x_rsc_rec.end_date := l_rsc_rec.end_date;
1399: END IF;
1400: IF (x_rsc_rec.jtot_object_code = OKC_API.G_MISS_CHAR)

Line 1400: IF (x_rsc_rec.jtot_object_code = OKC_API.G_MISS_CHAR)

1396: IF (x_rsc_rec.end_date = OKC_API.G_MISS_DATE)
1397: THEN
1398: x_rsc_rec.end_date := l_rsc_rec.end_date;
1399: END IF;
1400: IF (x_rsc_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
1401: THEN
1402: x_rsc_rec.JTOT_OBJECT_CODE := l_rsc_rec.JTOT_OBJECT_CODE;
1403: END IF;
1404: IF (x_rsc_rec.object_version_number = OKC_API.G_MISS_NUM)

Line 1404: IF (x_rsc_rec.object_version_number = OKC_API.G_MISS_NUM)

1400: IF (x_rsc_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
1401: THEN
1402: x_rsc_rec.JTOT_OBJECT_CODE := l_rsc_rec.JTOT_OBJECT_CODE;
1403: END IF;
1404: IF (x_rsc_rec.object_version_number = OKC_API.G_MISS_NUM)
1405: THEN
1406: x_rsc_rec.object_version_number := l_rsc_rec.object_version_number;
1407: END IF;
1408: IF (x_rsc_rec.created_by = OKC_API.G_MISS_NUM)

Line 1408: IF (x_rsc_rec.created_by = OKC_API.G_MISS_NUM)

1404: IF (x_rsc_rec.object_version_number = OKC_API.G_MISS_NUM)
1405: THEN
1406: x_rsc_rec.object_version_number := l_rsc_rec.object_version_number;
1407: END IF;
1408: IF (x_rsc_rec.created_by = OKC_API.G_MISS_NUM)
1409: THEN
1410: x_rsc_rec.created_by := l_rsc_rec.created_by;
1411: END IF;
1412: IF (x_rsc_rec.creation_date = OKC_API.G_MISS_DATE)

Line 1412: IF (x_rsc_rec.creation_date = OKC_API.G_MISS_DATE)

1408: IF (x_rsc_rec.created_by = OKC_API.G_MISS_NUM)
1409: THEN
1410: x_rsc_rec.created_by := l_rsc_rec.created_by;
1411: END IF;
1412: IF (x_rsc_rec.creation_date = OKC_API.G_MISS_DATE)
1413: THEN
1414: x_rsc_rec.creation_date := l_rsc_rec.creation_date;
1415: END IF;
1416: IF (x_rsc_rec.last_updated_by = OKC_API.G_MISS_NUM)

Line 1416: IF (x_rsc_rec.last_updated_by = OKC_API.G_MISS_NUM)

1412: IF (x_rsc_rec.creation_date = OKC_API.G_MISS_DATE)
1413: THEN
1414: x_rsc_rec.creation_date := l_rsc_rec.creation_date;
1415: END IF;
1416: IF (x_rsc_rec.last_updated_by = OKC_API.G_MISS_NUM)
1417: THEN
1418: x_rsc_rec.last_updated_by := l_rsc_rec.last_updated_by;
1419: END IF;
1420: IF (x_rsc_rec.last_update_date = OKC_API.G_MISS_DATE)

Line 1420: IF (x_rsc_rec.last_update_date = OKC_API.G_MISS_DATE)

1416: IF (x_rsc_rec.last_updated_by = OKC_API.G_MISS_NUM)
1417: THEN
1418: x_rsc_rec.last_updated_by := l_rsc_rec.last_updated_by;
1419: END IF;
1420: IF (x_rsc_rec.last_update_date = OKC_API.G_MISS_DATE)
1421: THEN
1422: x_rsc_rec.last_update_date := l_rsc_rec.last_update_date;
1423: END IF;
1424: IF (x_rsc_rec.last_update_login = OKC_API.G_MISS_NUM)

Line 1424: IF (x_rsc_rec.last_update_login = OKC_API.G_MISS_NUM)

1420: IF (x_rsc_rec.last_update_date = OKC_API.G_MISS_DATE)
1421: THEN
1422: x_rsc_rec.last_update_date := l_rsc_rec.last_update_date;
1423: END IF;
1424: IF (x_rsc_rec.last_update_login = OKC_API.G_MISS_NUM)
1425: THEN
1426: x_rsc_rec.last_update_login := l_rsc_rec.last_update_login;
1427: END IF;
1428: IF (x_rsc_rec.access_level= OKC_API.G_MISS_CHAR)

Line 1428: IF (x_rsc_rec.access_level= OKC_API.G_MISS_CHAR)

1424: IF (x_rsc_rec.last_update_login = OKC_API.G_MISS_NUM)
1425: THEN
1426: x_rsc_rec.last_update_login := l_rsc_rec.last_update_login;
1427: END IF;
1428: IF (x_rsc_rec.access_level= OKC_API.G_MISS_CHAR)
1429: THEN
1430: x_rsc_rec.access_level := l_rsc_rec.access_level;
1431: END IF;
1432: RETURN(l_return_status);

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

1437: FUNCTION Set_Attributes (
1438: p_rsc_rec IN rsc_rec_type,
1439: x_rsc_rec OUT NOCOPY rsc_rec_type
1440: ) RETURN VARCHAR2 IS
1441: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1442: BEGIN
1443: x_rsc_rec := p_rsc_rec;
1444: RETURN(l_return_status);
1445: END Set_Attributes;

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

1443: x_rsc_rec := p_rsc_rec;
1444: RETURN(l_return_status);
1445: END Set_Attributes;
1446: BEGIN
1447: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1448: p_init_msg_list,
1449: '_PVT',
1450: x_return_status);
1451: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1447: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1448: p_init_msg_list,
1449: '_PVT',
1450: x_return_status);
1451: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1453: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1454: RAISE OKC_API.G_EXCEPTION_ERROR;
1455: END IF;

Line 1452: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1448: p_init_msg_list,
1449: '_PVT',
1450: x_return_status);
1451: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1453: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1454: RAISE OKC_API.G_EXCEPTION_ERROR;
1455: END IF;
1456: --- Setting item attributes

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

1449: '_PVT',
1450: x_return_status);
1451: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1453: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1454: RAISE OKC_API.G_EXCEPTION_ERROR;
1455: END IF;
1456: --- Setting item attributes
1457: l_return_status := Set_Attributes(

Line 1454: RAISE OKC_API.G_EXCEPTION_ERROR;

1450: x_return_status);
1451: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1452: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1453: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1454: RAISE OKC_API.G_EXCEPTION_ERROR;
1455: END IF;
1456: --- Setting item attributes
1457: l_return_status := Set_Attributes(
1458: p_rsc_rec, -- IN

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

1457: l_return_status := Set_Attributes(
1458: p_rsc_rec, -- IN
1459: l_rsc_rec); -- OUT
1460: --- If any errors happen abort API
1461: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1462: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1463: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1464: RAISE OKC_API.G_EXCEPTION_ERROR;
1465: END IF;

Line 1462: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1458: p_rsc_rec, -- IN
1459: l_rsc_rec); -- OUT
1460: --- If any errors happen abort API
1461: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1462: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1463: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1464: RAISE OKC_API.G_EXCEPTION_ERROR;
1465: END IF;
1466: l_return_status := populate_new_record(l_rsc_rec, l_def_rsc_rec);

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

1459: l_rsc_rec); -- OUT
1460: --- If any errors happen abort API
1461: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1462: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1463: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1464: RAISE OKC_API.G_EXCEPTION_ERROR;
1465: END IF;
1466: l_return_status := populate_new_record(l_rsc_rec, l_def_rsc_rec);
1467: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1464: RAISE OKC_API.G_EXCEPTION_ERROR;

1460: --- If any errors happen abort API
1461: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1462: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1463: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1464: RAISE OKC_API.G_EXCEPTION_ERROR;
1465: END IF;
1466: l_return_status := populate_new_record(l_rsc_rec, l_def_rsc_rec);
1467: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

1463: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1464: RAISE OKC_API.G_EXCEPTION_ERROR;
1465: END IF;
1466: l_return_status := populate_new_record(l_rsc_rec, l_def_rsc_rec);
1467: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1469: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1470: RAISE OKC_API.G_EXCEPTION_ERROR;
1471: END IF;

Line 1468: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1464: RAISE OKC_API.G_EXCEPTION_ERROR;
1465: END IF;
1466: l_return_status := populate_new_record(l_rsc_rec, l_def_rsc_rec);
1467: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1469: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1470: RAISE OKC_API.G_EXCEPTION_ERROR;
1471: END IF;
1472: UPDATE OKC_ROLE_SOURCES

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

1465: END IF;
1466: l_return_status := populate_new_record(l_rsc_rec, l_def_rsc_rec);
1467: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1469: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1470: RAISE OKC_API.G_EXCEPTION_ERROR;
1471: END IF;
1472: UPDATE OKC_ROLE_SOURCES
1473: SET END_DATE = l_def_rsc_rec.end_date,

Line 1470: RAISE OKC_API.G_EXCEPTION_ERROR;

1466: l_return_status := populate_new_record(l_rsc_rec, l_def_rsc_rec);
1467: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1469: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1470: RAISE OKC_API.G_EXCEPTION_ERROR;
1471: END IF;
1472: UPDATE OKC_ROLE_SOURCES
1473: SET END_DATE = l_def_rsc_rec.end_date,
1474: JTOT_OBJECT_CODE = l_def_rsc_rec.JTOT_OBJECT_CODE,

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

1483: AND BUY_OR_SELL = l_def_rsc_rec.buy_or_sell
1484: AND START_DATE = l_def_rsc_rec.start_date;
1485:
1486: x_rsc_rec := l_def_rsc_rec;
1487: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1488: EXCEPTION
1489: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1490: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1491: (

Line 1489: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1485:
1486: x_rsc_rec := l_def_rsc_rec;
1487: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1488: EXCEPTION
1489: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1490: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1491: (
1492: l_api_name,
1493: G_PKG_NAME,

Line 1490: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1486: x_rsc_rec := l_def_rsc_rec;
1487: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1488: EXCEPTION
1489: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1490: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1491: (
1492: l_api_name,
1493: G_PKG_NAME,
1494: 'OKC_API.G_RET_STS_ERROR',

Line 1494: 'OKC_API.G_RET_STS_ERROR',

1490: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1491: (
1492: l_api_name,
1493: G_PKG_NAME,
1494: 'OKC_API.G_RET_STS_ERROR',
1495: x_msg_count,
1496: x_msg_data,
1497: '_PVT'
1498: );

Line 1499: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1495: x_msg_count,
1496: x_msg_data,
1497: '_PVT'
1498: );
1499: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1500: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1501: (
1502: l_api_name,
1503: G_PKG_NAME,

Line 1500: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1496: x_msg_data,
1497: '_PVT'
1498: );
1499: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1500: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1501: (
1502: l_api_name,
1503: G_PKG_NAME,
1504: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1504: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1500: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1501: (
1502: l_api_name,
1503: G_PKG_NAME,
1504: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1505: x_msg_count,
1506: x_msg_data,
1507: '_PVT'
1508: );

Line 1510: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1506: x_msg_data,
1507: '_PVT'
1508: );
1509: WHEN OTHERS THEN
1510: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1511: (
1512: l_api_name,
1513: G_PKG_NAME,
1514: 'OTHERS',

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

1530: x_rscv_rec OUT NOCOPY rscv_rec_type) IS
1531:
1532: l_api_version CONSTANT NUMBER := 1;
1533: l_api_name CONSTANT VARCHAR2(30) := 'V_update_row';
1534: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1535: l_rscv_rec rscv_rec_type := p_rscv_rec;
1536: l_def_rscv_rec rscv_rec_type;
1537: l_rsc_rec rsc_rec_type;
1538: lx_rsc_rec rsc_rec_type;

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

1557: x_rscv_rec OUT NOCOPY rscv_rec_type
1558: ) RETURN VARCHAR2 IS
1559: l_rscv_rec rscv_rec_type;
1560: l_row_notfound BOOLEAN := TRUE;
1561: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1562: BEGIN
1563: x_rscv_rec := p_rscv_rec;
1564: -- Get current database values
1565: l_rscv_rec := get_rec(p_rscv_rec, l_row_notfound);

Line 1567: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1563: x_rscv_rec := p_rscv_rec;
1564: -- Get current database values
1565: l_rscv_rec := get_rec(p_rscv_rec, l_row_notfound);
1566: IF (l_row_notfound) THEN
1567: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1568: END IF;
1569: IF (x_rscv_rec.rle_code = OKC_API.G_MISS_CHAR)
1570: THEN
1571: x_rscv_rec.rle_code := l_rscv_rec.rle_code;

Line 1569: IF (x_rscv_rec.rle_code = OKC_API.G_MISS_CHAR)

1565: l_rscv_rec := get_rec(p_rscv_rec, l_row_notfound);
1566: IF (l_row_notfound) THEN
1567: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1568: END IF;
1569: IF (x_rscv_rec.rle_code = OKC_API.G_MISS_CHAR)
1570: THEN
1571: x_rscv_rec.rle_code := l_rscv_rec.rle_code;
1572: END IF;
1573: IF (x_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

Line 1573: IF (x_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)

1569: IF (x_rscv_rec.rle_code = OKC_API.G_MISS_CHAR)
1570: THEN
1571: x_rscv_rec.rle_code := l_rscv_rec.rle_code;
1572: END IF;
1573: IF (x_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
1574: THEN
1575: x_rscv_rec.buy_or_sell := l_rscv_rec.buy_or_sell;
1576: END IF;
1577: IF (x_rscv_rec.start_date = OKC_API.G_MISS_DATE)

Line 1577: IF (x_rscv_rec.start_date = OKC_API.G_MISS_DATE)

1573: IF (x_rscv_rec.buy_or_sell = OKC_API.G_MISS_CHAR)
1574: THEN
1575: x_rscv_rec.buy_or_sell := l_rscv_rec.buy_or_sell;
1576: END IF;
1577: IF (x_rscv_rec.start_date = OKC_API.G_MISS_DATE)
1578: THEN
1579: x_rscv_rec.start_date := l_rscv_rec.start_date;
1580: END IF;
1581: IF (x_rscv_rec.end_date = OKC_API.G_MISS_DATE)

Line 1581: IF (x_rscv_rec.end_date = OKC_API.G_MISS_DATE)

1577: IF (x_rscv_rec.start_date = OKC_API.G_MISS_DATE)
1578: THEN
1579: x_rscv_rec.start_date := l_rscv_rec.start_date;
1580: END IF;
1581: IF (x_rscv_rec.end_date = OKC_API.G_MISS_DATE)
1582: THEN
1583: x_rscv_rec.end_date := l_rscv_rec.end_date;
1584: END IF;
1585: IF (x_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)

Line 1585: IF (x_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)

1581: IF (x_rscv_rec.end_date = OKC_API.G_MISS_DATE)
1582: THEN
1583: x_rscv_rec.end_date := l_rscv_rec.end_date;
1584: END IF;
1585: IF (x_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
1586: THEN
1587: x_rscv_rec.JTOT_OBJECT_CODE := l_rscv_rec.JTOT_OBJECT_CODE;
1588: END IF;
1589: IF (x_rscv_rec.object_version_number = OKC_API.G_MISS_NUM)

Line 1589: IF (x_rscv_rec.object_version_number = OKC_API.G_MISS_NUM)

1585: IF (x_rscv_rec.jtot_object_code = OKC_API.G_MISS_CHAR)
1586: THEN
1587: x_rscv_rec.JTOT_OBJECT_CODE := l_rscv_rec.JTOT_OBJECT_CODE;
1588: END IF;
1589: IF (x_rscv_rec.object_version_number = OKC_API.G_MISS_NUM)
1590: THEN
1591: x_rscv_rec.object_version_number := l_rscv_rec.object_version_number;
1592: END IF;
1593: IF (x_rscv_rec.created_by = OKC_API.G_MISS_NUM)

Line 1593: IF (x_rscv_rec.created_by = OKC_API.G_MISS_NUM)

1589: IF (x_rscv_rec.object_version_number = OKC_API.G_MISS_NUM)
1590: THEN
1591: x_rscv_rec.object_version_number := l_rscv_rec.object_version_number;
1592: END IF;
1593: IF (x_rscv_rec.created_by = OKC_API.G_MISS_NUM)
1594: THEN
1595: x_rscv_rec.created_by := l_rscv_rec.created_by;
1596: END IF;
1597: IF (x_rscv_rec.creation_date = OKC_API.G_MISS_DATE)

Line 1597: IF (x_rscv_rec.creation_date = OKC_API.G_MISS_DATE)

1593: IF (x_rscv_rec.created_by = OKC_API.G_MISS_NUM)
1594: THEN
1595: x_rscv_rec.created_by := l_rscv_rec.created_by;
1596: END IF;
1597: IF (x_rscv_rec.creation_date = OKC_API.G_MISS_DATE)
1598: THEN
1599: x_rscv_rec.creation_date := l_rscv_rec.creation_date;
1600: END IF;
1601: IF (x_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM)

Line 1601: IF (x_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM)

1597: IF (x_rscv_rec.creation_date = OKC_API.G_MISS_DATE)
1598: THEN
1599: x_rscv_rec.creation_date := l_rscv_rec.creation_date;
1600: END IF;
1601: IF (x_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM)
1602: THEN
1603: x_rscv_rec.last_updated_by := l_rscv_rec.last_updated_by;
1604: END IF;
1605: IF (x_rscv_rec.last_update_date = OKC_API.G_MISS_DATE)

Line 1605: IF (x_rscv_rec.last_update_date = OKC_API.G_MISS_DATE)

1601: IF (x_rscv_rec.last_updated_by = OKC_API.G_MISS_NUM)
1602: THEN
1603: x_rscv_rec.last_updated_by := l_rscv_rec.last_updated_by;
1604: END IF;
1605: IF (x_rscv_rec.last_update_date = OKC_API.G_MISS_DATE)
1606: THEN
1607: x_rscv_rec.last_update_date := l_rscv_rec.last_update_date;
1608: END IF;
1609: IF (x_rscv_rec.last_update_login = OKC_API.G_MISS_NUM)

Line 1609: IF (x_rscv_rec.last_update_login = OKC_API.G_MISS_NUM)

1605: IF (x_rscv_rec.last_update_date = OKC_API.G_MISS_DATE)
1606: THEN
1607: x_rscv_rec.last_update_date := l_rscv_rec.last_update_date;
1608: END IF;
1609: IF (x_rscv_rec.last_update_login = OKC_API.G_MISS_NUM)
1610: THEN
1611: x_rscv_rec.last_update_login := l_rscv_rec.last_update_login;
1612: END IF;
1613: IF (x_rscv_rec.access_level = OKC_API.G_MISS_CHAR)

Line 1613: IF (x_rscv_rec.access_level = OKC_API.G_MISS_CHAR)

1609: IF (x_rscv_rec.last_update_login = OKC_API.G_MISS_NUM)
1610: THEN
1611: x_rscv_rec.last_update_login := l_rscv_rec.last_update_login;
1612: END IF;
1613: IF (x_rscv_rec.access_level = OKC_API.G_MISS_CHAR)
1614: THEN
1615: x_rscv_rec.access_level := l_rscv_rec.access_level;
1616: END IF;
1617: RETURN(l_return_status);

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

1622: FUNCTION Set_Attributes (
1623: p_rscv_rec IN rscv_rec_type,
1624: x_rscv_rec OUT NOCOPY rscv_rec_type
1625: ) RETURN VARCHAR2 IS
1626: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1627: BEGIN
1628: x_rscv_rec := p_rscv_rec;
1629: x_rscv_rec.OBJECT_VERSION_NUMBER := NVL(x_rscv_rec.OBJECT_VERSION_NUMBER, 0) + 1;
1630: RETURN(l_return_status);

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

1629: x_rscv_rec.OBJECT_VERSION_NUMBER := NVL(x_rscv_rec.OBJECT_VERSION_NUMBER, 0) + 1;
1630: RETURN(l_return_status);
1631: END Set_Attributes;
1632: BEGIN
1633: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1634: G_PKG_NAME,
1635: p_init_msg_list,
1636: l_api_version,
1637: p_api_version,

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

1636: l_api_version,
1637: p_api_version,
1638: '_PVT',
1639: x_return_status);
1640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1643: RAISE OKC_API.G_EXCEPTION_ERROR;
1644: END IF;

Line 1641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1637: p_api_version,
1638: '_PVT',
1639: x_return_status);
1640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1643: RAISE OKC_API.G_EXCEPTION_ERROR;
1644: END IF;
1645: --- Setting item attributes

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

1638: '_PVT',
1639: x_return_status);
1640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1643: RAISE OKC_API.G_EXCEPTION_ERROR;
1644: END IF;
1645: --- Setting item attributes
1646: l_return_status := Set_Attributes(

Line 1643: RAISE OKC_API.G_EXCEPTION_ERROR;

1639: x_return_status);
1640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1641: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1642: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1643: RAISE OKC_API.G_EXCEPTION_ERROR;
1644: END IF;
1645: --- Setting item attributes
1646: l_return_status := Set_Attributes(
1647: p_rscv_rec, -- IN

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

1646: l_return_status := Set_Attributes(
1647: p_rscv_rec, -- IN
1648: l_rscv_rec); -- OUT
1649: --- If any errors happen abort API
1650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1653: RAISE OKC_API.G_EXCEPTION_ERROR;
1654: END IF;

Line 1651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1647: p_rscv_rec, -- IN
1648: l_rscv_rec); -- OUT
1649: --- If any errors happen abort API
1650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1653: RAISE OKC_API.G_EXCEPTION_ERROR;
1654: END IF;
1655: l_return_status := populate_new_record(l_rscv_rec, l_def_rscv_rec);

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

1648: l_rscv_rec); -- OUT
1649: --- If any errors happen abort API
1650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1653: RAISE OKC_API.G_EXCEPTION_ERROR;
1654: END IF;
1655: l_return_status := populate_new_record(l_rscv_rec, l_def_rscv_rec);
1656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1653: RAISE OKC_API.G_EXCEPTION_ERROR;

1649: --- If any errors happen abort API
1650: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1651: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1653: RAISE OKC_API.G_EXCEPTION_ERROR;
1654: END IF;
1655: l_return_status := populate_new_record(l_rscv_rec, l_def_rscv_rec);
1656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1657: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

1652: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1653: RAISE OKC_API.G_EXCEPTION_ERROR;
1654: END IF;
1655: l_return_status := populate_new_record(l_rscv_rec, l_def_rscv_rec);
1656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1657: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1658: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1659: RAISE OKC_API.G_EXCEPTION_ERROR;
1660: END IF;

Line 1657: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1653: RAISE OKC_API.G_EXCEPTION_ERROR;
1654: END IF;
1655: l_return_status := populate_new_record(l_rscv_rec, l_def_rscv_rec);
1656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1657: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1658: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1659: RAISE OKC_API.G_EXCEPTION_ERROR;
1660: END IF;
1661: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);

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

1654: END IF;
1655: l_return_status := populate_new_record(l_rscv_rec, l_def_rscv_rec);
1656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1657: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1658: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1659: RAISE OKC_API.G_EXCEPTION_ERROR;
1660: END IF;
1661: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);
1662: --- Validate all non-missing attributes (Item Level Validation)

Line 1659: RAISE OKC_API.G_EXCEPTION_ERROR;

1655: l_return_status := populate_new_record(l_rscv_rec, l_def_rscv_rec);
1656: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1657: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1658: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1659: RAISE OKC_API.G_EXCEPTION_ERROR;
1660: END IF;
1661: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);
1662: --- Validate all non-missing attributes (Item Level Validation)
1663: l_return_status := Validate_Attributes(l_def_rscv_rec);

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

1661: l_def_rscv_rec := fill_who_columns(l_def_rscv_rec);
1662: --- Validate all non-missing attributes (Item Level Validation)
1663: l_return_status := Validate_Attributes(l_def_rscv_rec);
1664: --- If any errors happen abort API
1665: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1666: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1667: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1668: RAISE OKC_API.G_EXCEPTION_ERROR;
1669: END IF;

Line 1666: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1662: --- Validate all non-missing attributes (Item Level Validation)
1663: l_return_status := Validate_Attributes(l_def_rscv_rec);
1664: --- If any errors happen abort API
1665: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1666: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1667: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1668: RAISE OKC_API.G_EXCEPTION_ERROR;
1669: END IF;
1670: l_return_status := Validate_Record(l_def_rscv_rec);

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

1663: l_return_status := Validate_Attributes(l_def_rscv_rec);
1664: --- If any errors happen abort API
1665: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1666: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1667: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1668: RAISE OKC_API.G_EXCEPTION_ERROR;
1669: END IF;
1670: l_return_status := Validate_Record(l_def_rscv_rec);
1671: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1668: RAISE OKC_API.G_EXCEPTION_ERROR;

1664: --- If any errors happen abort API
1665: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1666: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1667: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1668: RAISE OKC_API.G_EXCEPTION_ERROR;
1669: END IF;
1670: l_return_status := Validate_Record(l_def_rscv_rec);
1671: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

1667: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1668: RAISE OKC_API.G_EXCEPTION_ERROR;
1669: END IF;
1670: l_return_status := Validate_Record(l_def_rscv_rec);
1671: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_ERROR;
1675: END IF;

Line 1672: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1668: RAISE OKC_API.G_EXCEPTION_ERROR;
1669: END IF;
1670: l_return_status := Validate_Record(l_def_rscv_rec);
1671: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_ERROR;
1675: END IF;
1676:

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

1669: END IF;
1670: l_return_status := Validate_Record(l_def_rscv_rec);
1671: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_ERROR;
1675: END IF;
1676:
1677: --------------------------------------

Line 1674: RAISE OKC_API.G_EXCEPTION_ERROR;

1670: l_return_status := Validate_Record(l_def_rscv_rec);
1671: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_ERROR;
1675: END IF;
1676:
1677: --------------------------------------
1678: -- Move VIEW record to "Child" records

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

1688: x_msg_data,
1689: l_rsc_rec,
1690: lx_rsc_rec
1691: );
1692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_ERROR;
1696: END IF;

Line 1693: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1689: l_rsc_rec,
1690: lx_rsc_rec
1691: );
1692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_ERROR;
1696: END IF;
1697: migrate(lx_rsc_rec, l_def_rscv_rec);

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

1690: lx_rsc_rec
1691: );
1692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_ERROR;
1696: END IF;
1697: migrate(lx_rsc_rec, l_def_rscv_rec);
1698: x_rscv_rec := l_def_rscv_rec;

Line 1695: RAISE OKC_API.G_EXCEPTION_ERROR;

1691: );
1692: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1694: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_ERROR;
1696: END IF;
1697: migrate(lx_rsc_rec, l_def_rscv_rec);
1698: x_rscv_rec := l_def_rscv_rec;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1695: RAISE OKC_API.G_EXCEPTION_ERROR;
1696: END IF;
1697: migrate(lx_rsc_rec, l_def_rscv_rec);
1698: x_rscv_rec := l_def_rscv_rec;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION
1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (

Line 1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1697: migrate(lx_rsc_rec, l_def_rscv_rec);
1698: x_rscv_rec := l_def_rscv_rec;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION
1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (
1704: l_api_name,
1705: G_PKG_NAME,

Line 1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1698: x_rscv_rec := l_def_rscv_rec;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION
1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (
1704: l_api_name,
1705: G_PKG_NAME,
1706: 'OKC_API.G_RET_STS_ERROR',

Line 1706: 'OKC_API.G_RET_STS_ERROR',

1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (
1704: l_api_name,
1705: G_PKG_NAME,
1706: 'OKC_API.G_RET_STS_ERROR',
1707: x_msg_count,
1708: x_msg_data,
1709: '_PVT'
1710: );

Line 1711: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1707: x_msg_count,
1708: x_msg_data,
1709: '_PVT'
1710: );
1711: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1712: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1713: (
1714: l_api_name,
1715: G_PKG_NAME,

Line 1712: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1708: x_msg_data,
1709: '_PVT'
1710: );
1711: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1712: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1713: (
1714: l_api_name,
1715: G_PKG_NAME,
1716: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1716: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1712: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1713: (
1714: l_api_name,
1715: G_PKG_NAME,
1716: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1717: x_msg_count,
1718: x_msg_data,
1719: '_PVT'
1720: );

Line 1722: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1718: x_msg_data,
1719: '_PVT'
1720: );
1721: WHEN OTHERS THEN
1722: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1723: (
1724: l_api_name,
1725: G_PKG_NAME,
1726: 'OTHERS',

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

1742: x_rscv_tbl OUT NOCOPY rscv_tbl_type) IS
1743:
1744: l_api_version CONSTANT NUMBER := 1;
1745: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
1746: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1747: i NUMBER := 0;
1748: BEGIN
1749: OKC_API.init_msg_list(p_init_msg_list);
1750: -- Make sure PL/SQL table has records in it before passing

Line 1749: OKC_API.init_msg_list(p_init_msg_list);

1745: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
1746: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1747: i NUMBER := 0;
1748: BEGIN
1749: OKC_API.init_msg_list(p_init_msg_list);
1750: -- Make sure PL/SQL table has records in it before passing
1751: IF (p_rscv_tbl.COUNT > 0) THEN
1752: i := p_rscv_tbl.FIRST;
1753: LOOP

Line 1756: p_init_msg_list => OKC_API.G_FALSE,

1752: i := p_rscv_tbl.FIRST;
1753: LOOP
1754: update_row (
1755: p_api_version => p_api_version,
1756: p_init_msg_list => OKC_API.G_FALSE,
1757: x_return_status => x_return_status,
1758: x_msg_count => x_msg_count,
1759: x_msg_data => x_msg_data,
1760: p_rscv_rec => p_rscv_tbl(i),

Line 1767: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1763: i := p_rscv_tbl.NEXT(i);
1764: END LOOP;
1765: END IF;
1766: EXCEPTION
1767: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1768: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1769: (
1770: l_api_name,
1771: G_PKG_NAME,

Line 1768: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1764: END LOOP;
1765: END IF;
1766: EXCEPTION
1767: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1768: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1769: (
1770: l_api_name,
1771: G_PKG_NAME,
1772: 'OKC_API.G_RET_STS_ERROR',

Line 1772: 'OKC_API.G_RET_STS_ERROR',

1768: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1769: (
1770: l_api_name,
1771: G_PKG_NAME,
1772: 'OKC_API.G_RET_STS_ERROR',
1773: x_msg_count,
1774: x_msg_data,
1775: '_PVT'
1776: );

Line 1777: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1773: x_msg_count,
1774: x_msg_data,
1775: '_PVT'
1776: );
1777: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1778: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1779: (
1780: l_api_name,
1781: G_PKG_NAME,

Line 1778: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1774: x_msg_data,
1775: '_PVT'
1776: );
1777: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1778: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1779: (
1780: l_api_name,
1781: G_PKG_NAME,
1782: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1782: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1778: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1779: (
1780: l_api_name,
1781: G_PKG_NAME,
1782: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1783: x_msg_count,
1784: x_msg_data,
1785: '_PVT'
1786: );

Line 1788: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1784: x_msg_data,
1785: '_PVT'
1786: );
1787: WHEN OTHERS THEN
1788: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1789: (
1790: l_api_name,
1791: G_PKG_NAME,
1792: 'OTHERS',

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

1810: p_rsc_rec IN rsc_rec_type) IS
1811:
1812: l_api_version CONSTANT NUMBER := 1;
1813: l_api_name CONSTANT VARCHAR2(30) := 'SOURCES_delete_row';
1814: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1815: l_rsc_rec rsc_rec_type:= p_rsc_rec;
1816: l_row_notfound BOOLEAN := TRUE;
1817: BEGIN
1818: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1814: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1815: l_rsc_rec rsc_rec_type:= p_rsc_rec;
1816: l_row_notfound BOOLEAN := TRUE;
1817: BEGIN
1818: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1819: p_init_msg_list,
1820: '_PVT',
1821: x_return_status);
1822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1818: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1819: p_init_msg_list,
1820: '_PVT',
1821: x_return_status);
1822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1823: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1825: RAISE OKC_API.G_EXCEPTION_ERROR;
1826: END IF;

Line 1823: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1819: p_init_msg_list,
1820: '_PVT',
1821: x_return_status);
1822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1823: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1825: RAISE OKC_API.G_EXCEPTION_ERROR;
1826: END IF;
1827: DELETE FROM OKC_ROLE_SOURCES

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

1820: '_PVT',
1821: x_return_status);
1822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1823: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1825: RAISE OKC_API.G_EXCEPTION_ERROR;
1826: END IF;
1827: DELETE FROM OKC_ROLE_SOURCES
1828: WHERE RLE_CODE = l_rsc_rec.rle_code AND

Line 1825: RAISE OKC_API.G_EXCEPTION_ERROR;

1821: x_return_status);
1822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1823: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1825: RAISE OKC_API.G_EXCEPTION_ERROR;
1826: END IF;
1827: DELETE FROM OKC_ROLE_SOURCES
1828: WHERE RLE_CODE = l_rsc_rec.rle_code AND
1829: BUY_OR_SELL = l_rsc_rec.buy_or_sell AND

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

1828: WHERE RLE_CODE = l_rsc_rec.rle_code AND
1829: BUY_OR_SELL = l_rsc_rec.buy_or_sell AND
1830: START_DATE = l_rsc_rec.start_date;
1831:
1832: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1833: EXCEPTION
1834: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1835: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1836: (

Line 1834: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1830: START_DATE = l_rsc_rec.start_date;
1831:
1832: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1833: EXCEPTION
1834: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1835: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1836: (
1837: l_api_name,
1838: G_PKG_NAME,

Line 1835: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1831:
1832: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1833: EXCEPTION
1834: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1835: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1836: (
1837: l_api_name,
1838: G_PKG_NAME,
1839: 'OKC_API.G_RET_STS_ERROR',

Line 1839: 'OKC_API.G_RET_STS_ERROR',

1835: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1836: (
1837: l_api_name,
1838: G_PKG_NAME,
1839: 'OKC_API.G_RET_STS_ERROR',
1840: x_msg_count,
1841: x_msg_data,
1842: '_PVT'
1843: );

Line 1844: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1840: x_msg_count,
1841: x_msg_data,
1842: '_PVT'
1843: );
1844: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1845: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1846: (
1847: l_api_name,
1848: G_PKG_NAME,

Line 1845: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1841: x_msg_data,
1842: '_PVT'
1843: );
1844: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1845: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1846: (
1847: l_api_name,
1848: G_PKG_NAME,
1849: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1849: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1845: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1846: (
1847: l_api_name,
1848: G_PKG_NAME,
1849: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1850: x_msg_count,
1851: x_msg_data,
1852: '_PVT'
1853: );

Line 1855: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1851: x_msg_data,
1852: '_PVT'
1853: );
1854: WHEN OTHERS THEN
1855: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1856: (
1857: l_api_name,
1858: G_PKG_NAME,
1859: 'OTHERS',

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

1874: p_rscv_rec IN rscv_rec_type) IS
1875:
1876: l_api_version CONSTANT NUMBER := 1;
1877: l_api_name CONSTANT VARCHAR2(30) := 'V_delete_row';
1878: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1879: l_rscv_rec rscv_rec_type := p_rscv_rec;
1880: l_rsc_rec rsc_rec_type;
1881: BEGIN
1882: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1878: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1879: l_rscv_rec rscv_rec_type := p_rscv_rec;
1880: l_rsc_rec rsc_rec_type;
1881: BEGIN
1882: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1883: G_PKG_NAME,
1884: p_init_msg_list,
1885: l_api_version,
1886: p_api_version,

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

1885: l_api_version,
1886: p_api_version,
1887: '_PVT',
1888: x_return_status);
1889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1892: RAISE OKC_API.G_EXCEPTION_ERROR;
1893: END IF;

Line 1890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1886: p_api_version,
1887: '_PVT',
1888: x_return_status);
1889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1892: RAISE OKC_API.G_EXCEPTION_ERROR;
1893: END IF;
1894: --------------------------------------

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

1887: '_PVT',
1888: x_return_status);
1889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1892: RAISE OKC_API.G_EXCEPTION_ERROR;
1893: END IF;
1894: --------------------------------------
1895: -- Move VIEW record to "Child" records

Line 1892: RAISE OKC_API.G_EXCEPTION_ERROR;

1888: x_return_status);
1889: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1891: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1892: RAISE OKC_API.G_EXCEPTION_ERROR;
1893: END IF;
1894: --------------------------------------
1895: -- Move VIEW record to "Child" records
1896: --------------------------------------

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

1904: x_msg_count,
1905: x_msg_data,
1906: l_rsc_rec
1907: );
1908: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1909: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1910: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1911: RAISE OKC_API.G_EXCEPTION_ERROR;
1912: END IF;

Line 1909: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1905: x_msg_data,
1906: l_rsc_rec
1907: );
1908: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1909: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1910: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1911: RAISE OKC_API.G_EXCEPTION_ERROR;
1912: END IF;
1913: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1906: l_rsc_rec
1907: );
1908: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1909: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1910: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1911: RAISE OKC_API.G_EXCEPTION_ERROR;
1912: END IF;
1913: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1914: EXCEPTION

Line 1911: RAISE OKC_API.G_EXCEPTION_ERROR;

1907: );
1908: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1909: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1910: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1911: RAISE OKC_API.G_EXCEPTION_ERROR;
1912: END IF;
1913: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1914: EXCEPTION
1915: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1909: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1910: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1911: RAISE OKC_API.G_EXCEPTION_ERROR;
1912: END IF;
1913: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1914: EXCEPTION
1915: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1916: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1917: (

Line 1915: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1911: RAISE OKC_API.G_EXCEPTION_ERROR;
1912: END IF;
1913: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1914: EXCEPTION
1915: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1916: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1917: (
1918: l_api_name,
1919: G_PKG_NAME,

Line 1916: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1912: END IF;
1913: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1914: EXCEPTION
1915: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1916: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1917: (
1918: l_api_name,
1919: G_PKG_NAME,
1920: 'OKC_API.G_RET_STS_ERROR',

Line 1920: 'OKC_API.G_RET_STS_ERROR',

1916: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1917: (
1918: l_api_name,
1919: G_PKG_NAME,
1920: 'OKC_API.G_RET_STS_ERROR',
1921: x_msg_count,
1922: x_msg_data,
1923: '_PVT'
1924: );

Line 1925: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1921: x_msg_count,
1922: x_msg_data,
1923: '_PVT'
1924: );
1925: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1926: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1927: (
1928: l_api_name,
1929: G_PKG_NAME,

Line 1926: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1922: x_msg_data,
1923: '_PVT'
1924: );
1925: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1926: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1927: (
1928: l_api_name,
1929: G_PKG_NAME,
1930: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1930: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1926: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1927: (
1928: l_api_name,
1929: G_PKG_NAME,
1930: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1931: x_msg_count,
1932: x_msg_data,
1933: '_PVT'
1934: );

Line 1936: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1932: x_msg_data,
1933: '_PVT'
1934: );
1935: WHEN OTHERS THEN
1936: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1937: (
1938: l_api_name,
1939: G_PKG_NAME,
1940: 'OTHERS',

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

1955: p_rscv_tbl IN rscv_tbl_type) IS
1956:
1957: l_api_version CONSTANT NUMBER := 1;
1958: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
1959: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1960: i NUMBER := 0;
1961: BEGIN
1962: OKC_API.init_msg_list(p_init_msg_list);
1963: -- Make sure PL/SQL table has records in it before passing

Line 1962: OKC_API.init_msg_list(p_init_msg_list);

1958: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
1959: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1960: i NUMBER := 0;
1961: BEGIN
1962: OKC_API.init_msg_list(p_init_msg_list);
1963: -- Make sure PL/SQL table has records in it before passing
1964: IF (p_rscv_tbl.COUNT > 0) THEN
1965: i := p_rscv_tbl.FIRST;
1966: LOOP

Line 1969: p_init_msg_list => OKC_API.G_FALSE,

1965: i := p_rscv_tbl.FIRST;
1966: LOOP
1967: delete_row (
1968: p_api_version => p_api_version,
1969: p_init_msg_list => OKC_API.G_FALSE,
1970: x_return_status => x_return_status,
1971: x_msg_count => x_msg_count,
1972: x_msg_data => x_msg_data,
1973: p_rscv_rec => p_rscv_tbl(i));

Line 1979: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1975: i := p_rscv_tbl.NEXT(i);
1976: END LOOP;
1977: END IF;
1978: EXCEPTION
1979: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1980: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1981: (
1982: l_api_name,
1983: G_PKG_NAME,

Line 1980: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1976: END LOOP;
1977: END IF;
1978: EXCEPTION
1979: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1980: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1981: (
1982: l_api_name,
1983: G_PKG_NAME,
1984: 'OKC_API.G_RET_STS_ERROR',

Line 1984: 'OKC_API.G_RET_STS_ERROR',

1980: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1981: (
1982: l_api_name,
1983: G_PKG_NAME,
1984: 'OKC_API.G_RET_STS_ERROR',
1985: x_msg_count,
1986: x_msg_data,
1987: '_PVT'
1988: );

Line 1989: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1985: x_msg_count,
1986: x_msg_data,
1987: '_PVT'
1988: );
1989: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1990: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1991: (
1992: l_api_name,
1993: G_PKG_NAME,

Line 1990: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1986: x_msg_data,
1987: '_PVT'
1988: );
1989: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1990: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1991: (
1992: l_api_name,
1993: G_PKG_NAME,
1994: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1994: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1990: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1991: (
1992: l_api_name,
1993: G_PKG_NAME,
1994: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1995: x_msg_count,
1996: x_msg_data,
1997: '_PVT'
1998: );

Line 2000: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1996: x_msg_data,
1997: '_PVT'
1998: );
1999: WHEN OTHERS THEN
2000: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
2001: (
2002: l_api_name,
2003: G_PKG_NAME,
2004: 'OTHERS',