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_CPR_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 155: IF (l_cprv_rec.crt_id = OKC_API.G_MISS_NUM) THEN

151: p_cprv_rec IN cprv_rec_type
152: ) RETURN cprv_rec_type IS
153: l_cprv_rec cprv_rec_type := p_cprv_rec;
154: BEGIN
155: IF (l_cprv_rec.crt_id = OKC_API.G_MISS_NUM) THEN
156: l_cprv_rec.crt_id := NULL;
157: END IF;
158: IF (l_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) THEN
159: l_cprv_rec.cpl_id := NULL;

Line 158: IF (l_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) THEN

154: BEGIN
155: IF (l_cprv_rec.crt_id = OKC_API.G_MISS_NUM) THEN
156: l_cprv_rec.crt_id := NULL;
157: END IF;
158: IF (l_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) THEN
159: l_cprv_rec.cpl_id := NULL;
160: END IF;
161: IF (l_cprv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
162: l_cprv_rec.object_version_number := NULL;

Line 161: IF (l_cprv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN

157: END IF;
158: IF (l_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) THEN
159: l_cprv_rec.cpl_id := NULL;
160: END IF;
161: IF (l_cprv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
162: l_cprv_rec.object_version_number := NULL;
163: END IF;
164: IF (l_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE) THEN
165: l_cprv_rec.acceptance_date := NULL;

Line 164: IF (l_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE) THEN

160: END IF;
161: IF (l_cprv_rec.object_version_number = OKC_API.G_MISS_NUM) THEN
162: l_cprv_rec.object_version_number := NULL;
163: END IF;
164: IF (l_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE) THEN
165: l_cprv_rec.acceptance_date := NULL;
166: END IF;
167: IF (l_cprv_rec.created_by = OKC_API.G_MISS_NUM) THEN
168: l_cprv_rec.created_by := NULL;

Line 167: IF (l_cprv_rec.created_by = OKC_API.G_MISS_NUM) THEN

163: END IF;
164: IF (l_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE) THEN
165: l_cprv_rec.acceptance_date := NULL;
166: END IF;
167: IF (l_cprv_rec.created_by = OKC_API.G_MISS_NUM) THEN
168: l_cprv_rec.created_by := NULL;
169: END IF;
170: IF (l_cprv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
171: l_cprv_rec.creation_date := NULL;

Line 170: IF (l_cprv_rec.creation_date = OKC_API.G_MISS_DATE) THEN

166: END IF;
167: IF (l_cprv_rec.created_by = OKC_API.G_MISS_NUM) THEN
168: l_cprv_rec.created_by := NULL;
169: END IF;
170: IF (l_cprv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
171: l_cprv_rec.creation_date := NULL;
172: END IF;
173: IF (l_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
174: l_cprv_rec.last_updated_by := NULL;

Line 173: IF (l_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN

169: END IF;
170: IF (l_cprv_rec.creation_date = OKC_API.G_MISS_DATE) THEN
171: l_cprv_rec.creation_date := NULL;
172: END IF;
173: IF (l_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
174: l_cprv_rec.last_updated_by := NULL;
175: END IF;
176: IF (l_cprv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
177: l_cprv_rec.last_update_date := NULL;

Line 176: IF (l_cprv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN

172: END IF;
173: IF (l_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM) THEN
174: l_cprv_rec.last_updated_by := NULL;
175: END IF;
176: IF (l_cprv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
177: l_cprv_rec.last_update_date := NULL;
178: END IF;
179: IF (l_cprv_rec.last_update_login = OKC_API.G_MISS_NUM) THEN
180: l_cprv_rec.last_update_login := NULL;

Line 179: IF (l_cprv_rec.last_update_login = OKC_API.G_MISS_NUM) THEN

175: END IF;
176: IF (l_cprv_rec.last_update_date = OKC_API.G_MISS_DATE) THEN
177: l_cprv_rec.last_update_date := NULL;
178: END IF;
179: IF (l_cprv_rec.last_update_login = OKC_API.G_MISS_NUM) THEN
180: l_cprv_rec.last_update_login := NULL;
181: END IF;
182: RETURN(l_cprv_rec);
183: END null_out_defaults;

Line 206: x_return_status := OKC_API.G_RET_STS_SUCCESS;

202: select 'x'
203: from OKC_K_PARTY_ROLES_B
204: where id = p_cprv_rec.cpl_id;
205: begin
206: x_return_status := OKC_API.G_RET_STS_SUCCESS;
207: if (p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) then
208: return;
209: end if;
210: if (p_cprv_rec.cpl_id is NULL) then

Line 207: if (p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) then

203: from OKC_K_PARTY_ROLES_B
204: where id = p_cprv_rec.cpl_id;
205: begin
206: x_return_status := OKC_API.G_RET_STS_SUCCESS;
207: if (p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) then
208: return;
209: end if;
210: if (p_cprv_rec.cpl_id is NULL) then
211: OKC_API.set_message(p_app_name => g_app_name,

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

207: if (p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM) then
208: return;
209: end if;
210: if (p_cprv_rec.cpl_id is NULL) then
211: OKC_API.set_message(p_app_name => g_app_name,
212: p_msg_name => G_REQUIRED_VALUE,
213: p_token1 => G_COL_NAME_TOKEN,
214: p_token1_value => 'CPL_ID');
215: raise G_EXCEPTION_HALT_VALIDATION;

Line 221: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CPL_ID');

217: open l_cpl_csr;
218: fetch l_cpl_csr into l_dummy_var;
219: close l_cpl_csr;
220: if (l_dummy_var = '?') then
221: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CPL_ID');
222: raise G_EXCEPTION_HALT_VALIDATION;
223: end if;
224: exception
225: when G_EXCEPTION_HALT_VALIDATION then

Line 226: x_return_status := OKC_API.G_RET_STS_ERROR;

222: raise G_EXCEPTION_HALT_VALIDATION;
223: end if;
224: exception
225: when G_EXCEPTION_HALT_VALIDATION then
226: x_return_status := OKC_API.G_RET_STS_ERROR;
227: when OTHERS then
228: if l_cpl_csr%ISOPEN then
229: close l_cpl_csr;
230: end if;

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

227: when OTHERS then
228: if l_cpl_csr%ISOPEN then
229: close l_cpl_csr;
230: end if;
231: OKC_API.set_message(p_app_name => g_app_name,
232: p_msg_name => g_unexpected_error,
233: p_token1 => g_sqlcode_token,
234: p_token1_value => sqlcode,
235: p_token2 => g_sqlerrm_token,

Line 237: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

233: p_token1 => g_sqlcode_token,
234: p_token1_value => sqlcode,
235: p_token2 => g_sqlerrm_token,
236: p_token2_value => sqlerrm);
237: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
238: end validate_cpl_id;
239:
240: -- Start of comments
241: --

Line 257: x_return_status := OKC_API.G_RET_STS_SUCCESS;

253: select 'x'
254: from OKC_CHANGE_REQUESTS_B
255: where id = p_cprv_rec.crt_id;
256: begin
257: x_return_status := OKC_API.G_RET_STS_SUCCESS;
258: if (p_cprv_rec.crt_id = OKC_API.G_MISS_NUM) then
259: return;
260: end if;
261: if (p_cprv_rec.crt_id is NULL) then

Line 258: if (p_cprv_rec.crt_id = OKC_API.G_MISS_NUM) then

254: from OKC_CHANGE_REQUESTS_B
255: where id = p_cprv_rec.crt_id;
256: begin
257: x_return_status := OKC_API.G_RET_STS_SUCCESS;
258: if (p_cprv_rec.crt_id = OKC_API.G_MISS_NUM) then
259: return;
260: end if;
261: if (p_cprv_rec.crt_id is NULL) then
262: OKC_API.set_message(p_app_name => g_app_name,

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

258: if (p_cprv_rec.crt_id = OKC_API.G_MISS_NUM) then
259: return;
260: end if;
261: if (p_cprv_rec.crt_id is NULL) then
262: OKC_API.set_message(p_app_name => g_app_name,
263: p_msg_name => G_REQUIRED_VALUE,
264: p_token1 => G_COL_NAME_TOKEN,
265: p_token1_value => 'CRT_ID');
266: raise G_EXCEPTION_HALT_VALIDATION;

Line 272: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CRT_ID');

268: open l_crt_csr;
269: fetch l_crt_csr into l_dummy_var;
270: close l_crt_csr;
271: if (l_dummy_var = '?') then
272: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CRT_ID');
273: raise G_EXCEPTION_HALT_VALIDATION;
274: end if;
275: exception
276: when G_EXCEPTION_HALT_VALIDATION then

Line 277: x_return_status := OKC_API.G_RET_STS_ERROR;

273: raise G_EXCEPTION_HALT_VALIDATION;
274: end if;
275: exception
276: when G_EXCEPTION_HALT_VALIDATION then
277: x_return_status := OKC_API.G_RET_STS_ERROR;
278: when OTHERS then
279: if l_crt_csr%ISOPEN then
280: close l_crt_csr;
281: end if;

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

278: when OTHERS then
279: if l_crt_csr%ISOPEN then
280: close l_crt_csr;
281: end if;
282: OKC_API.set_message(p_app_name => g_app_name,
283: p_msg_name => g_unexpected_error,
284: p_token1 => g_sqlcode_token,
285: p_token1_value => sqlcode,
286: p_token2 => g_sqlerrm_token,

Line 288: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

284: p_token1 => g_sqlcode_token,
285: p_token1_value => sqlcode,
286: p_token2 => g_sqlerrm_token,
287: p_token2_value => sqlerrm);
288: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
289: end validate_crt_id;
290: /*+++++++++++++End of hand code +++++++++++++++++++*/
291: -----------------------------------------------------
292: -- Validate_Attributes for:OKC_CHANGE_PARTY_ROLE_V --

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

293: -----------------------------------------------------
294: FUNCTION Validate_Attributes (
295: p_cprv_rec IN cprv_rec_type
296: ) RETURN VARCHAR2 IS
297: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
298: /*-------------Commented in favor of hand code------
299: BEGIN
300: IF p_cprv_rec.crt_id = OKC_API.G_MISS_NUM OR
301: p_cprv_rec.crt_id IS NULL

Line 300: IF p_cprv_rec.crt_id = OKC_API.G_MISS_NUM OR

296: ) RETURN VARCHAR2 IS
297: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
298: /*-------------Commented in favor of hand code------
299: BEGIN
300: IF p_cprv_rec.crt_id = OKC_API.G_MISS_NUM OR
301: p_cprv_rec.crt_id IS NULL
302: THEN
303: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'crt_id');
304: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 303: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'crt_id');

299: BEGIN
300: IF p_cprv_rec.crt_id = OKC_API.G_MISS_NUM OR
301: p_cprv_rec.crt_id IS NULL
302: THEN
303: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'crt_id');
304: l_return_status := OKC_API.G_RET_STS_ERROR;
305: ELSIF p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM OR
306: p_cprv_rec.cpl_id IS NULL
307: THEN

Line 304: l_return_status := OKC_API.G_RET_STS_ERROR;

300: IF p_cprv_rec.crt_id = OKC_API.G_MISS_NUM OR
301: p_cprv_rec.crt_id IS NULL
302: THEN
303: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'crt_id');
304: l_return_status := OKC_API.G_RET_STS_ERROR;
305: ELSIF p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM OR
306: p_cprv_rec.cpl_id IS NULL
307: THEN
308: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'cpl_id');

Line 305: ELSIF p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM OR

301: p_cprv_rec.crt_id IS NULL
302: THEN
303: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'crt_id');
304: l_return_status := OKC_API.G_RET_STS_ERROR;
305: ELSIF p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM OR
306: p_cprv_rec.cpl_id IS NULL
307: THEN
308: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'cpl_id');
309: l_return_status := OKC_API.G_RET_STS_ERROR;

Line 308: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'cpl_id');

304: l_return_status := OKC_API.G_RET_STS_ERROR;
305: ELSIF p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM OR
306: p_cprv_rec.cpl_id IS NULL
307: THEN
308: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'cpl_id');
309: l_return_status := OKC_API.G_RET_STS_ERROR;
310: ELSIF p_cprv_rec.object_version_number = OKC_API.G_MISS_NUM OR
311: p_cprv_rec.object_version_number IS NULL
312: THEN

Line 309: l_return_status := OKC_API.G_RET_STS_ERROR;

305: ELSIF p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM OR
306: p_cprv_rec.cpl_id IS NULL
307: THEN
308: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'cpl_id');
309: l_return_status := OKC_API.G_RET_STS_ERROR;
310: ELSIF p_cprv_rec.object_version_number = OKC_API.G_MISS_NUM OR
311: p_cprv_rec.object_version_number IS NULL
312: THEN
313: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');

Line 310: ELSIF p_cprv_rec.object_version_number = OKC_API.G_MISS_NUM OR

306: p_cprv_rec.cpl_id IS NULL
307: THEN
308: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'cpl_id');
309: l_return_status := OKC_API.G_RET_STS_ERROR;
310: ELSIF p_cprv_rec.object_version_number = OKC_API.G_MISS_NUM OR
311: p_cprv_rec.object_version_number IS NULL
312: THEN
313: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
314: l_return_status := OKC_API.G_RET_STS_ERROR;

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

309: l_return_status := OKC_API.G_RET_STS_ERROR;
310: ELSIF p_cprv_rec.object_version_number = OKC_API.G_MISS_NUM OR
311: p_cprv_rec.object_version_number IS NULL
312: THEN
313: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
314: l_return_status := OKC_API.G_RET_STS_ERROR;
315: END IF;
316: RETURN(l_return_status);
317: END Validate_Attributes;

Line 314: l_return_status := OKC_API.G_RET_STS_ERROR;

310: ELSIF p_cprv_rec.object_version_number = OKC_API.G_MISS_NUM OR
311: p_cprv_rec.object_version_number IS NULL
312: THEN
313: OKC_API.set_message(G_APP_NAME, G_REQUIRED_VALUE,G_COL_NAME_TOKEN,'object_version_number');
314: l_return_status := OKC_API.G_RET_STS_ERROR;
315: END IF;
316: RETURN(l_return_status);
317: END Validate_Attributes;
318: ---------------End of the commented code-----------*/

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

316: RETURN(l_return_status);
317: END Validate_Attributes;
318: ---------------End of the commented code-----------*/
319: /*+++++++++++++Start of hand code +++++++++++++++++*/
320: x_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;
321: BEGIN
322: -- call each column-level validation
323: validate_cpl_id(x_return_status => l_return_status,
324: p_cprv_rec => p_cprv_rec);

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

321: BEGIN
322: -- call each column-level validation
323: validate_cpl_id(x_return_status => l_return_status,
324: p_cprv_rec => p_cprv_rec);
325: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
326: return OKC_API.G_RET_STS_UNEXP_ERROR;
327: end if;
328: if (l_return_status = OKC_API.G_RET_STS_ERROR
329: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

Line 326: return OKC_API.G_RET_STS_UNEXP_ERROR;

322: -- call each column-level validation
323: validate_cpl_id(x_return_status => l_return_status,
324: p_cprv_rec => p_cprv_rec);
325: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
326: return OKC_API.G_RET_STS_UNEXP_ERROR;
327: end if;
328: if (l_return_status = OKC_API.G_RET_STS_ERROR
329: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
330: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 328: if (l_return_status = OKC_API.G_RET_STS_ERROR

324: p_cprv_rec => p_cprv_rec);
325: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
326: return OKC_API.G_RET_STS_UNEXP_ERROR;
327: end if;
328: if (l_return_status = OKC_API.G_RET_STS_ERROR
329: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
330: x_return_status := OKC_API.G_RET_STS_ERROR;
331: end if;
332: --

Line 329: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

325: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
326: return OKC_API.G_RET_STS_UNEXP_ERROR;
327: end if;
328: if (l_return_status = OKC_API.G_RET_STS_ERROR
329: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
330: x_return_status := OKC_API.G_RET_STS_ERROR;
331: end if;
332: --
333: validate_crt_id(x_return_status => l_return_status,

Line 330: x_return_status := OKC_API.G_RET_STS_ERROR;

326: return OKC_API.G_RET_STS_UNEXP_ERROR;
327: end if;
328: if (l_return_status = OKC_API.G_RET_STS_ERROR
329: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
330: x_return_status := OKC_API.G_RET_STS_ERROR;
331: end if;
332: --
333: validate_crt_id(x_return_status => l_return_status,
334: p_cprv_rec => p_cprv_rec);

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

331: end if;
332: --
333: validate_crt_id(x_return_status => l_return_status,
334: p_cprv_rec => p_cprv_rec);
335: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
336: return OKC_API.G_RET_STS_UNEXP_ERROR;
337: end if;
338: if (l_return_status = OKC_API.G_RET_STS_ERROR
339: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

Line 336: return OKC_API.G_RET_STS_UNEXP_ERROR;

332: --
333: validate_crt_id(x_return_status => l_return_status,
334: p_cprv_rec => p_cprv_rec);
335: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
336: return OKC_API.G_RET_STS_UNEXP_ERROR;
337: end if;
338: if (l_return_status = OKC_API.G_RET_STS_ERROR
339: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
340: x_return_status := OKC_API.G_RET_STS_ERROR;

Line 338: if (l_return_status = OKC_API.G_RET_STS_ERROR

334: p_cprv_rec => p_cprv_rec);
335: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
336: return OKC_API.G_RET_STS_UNEXP_ERROR;
337: end if;
338: if (l_return_status = OKC_API.G_RET_STS_ERROR
339: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
340: x_return_status := OKC_API.G_RET_STS_ERROR;
341: end if;
342: return x_return_status;

Line 339: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then

335: if (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
336: return OKC_API.G_RET_STS_UNEXP_ERROR;
337: end if;
338: if (l_return_status = OKC_API.G_RET_STS_ERROR
339: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
340: x_return_status := OKC_API.G_RET_STS_ERROR;
341: end if;
342: return x_return_status;
343: exception

Line 340: x_return_status := OKC_API.G_RET_STS_ERROR;

336: return OKC_API.G_RET_STS_UNEXP_ERROR;
337: end if;
338: if (l_return_status = OKC_API.G_RET_STS_ERROR
339: and x_return_status = OKC_API.G_RET_STS_SUCCESS) then
340: x_return_status := OKC_API.G_RET_STS_ERROR;
341: end if;
342: return x_return_status;
343: exception
344: when OTHERS then

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

342: return x_return_status;
343: exception
344: when OTHERS then
345: -- store SQL error message on message stack for caller
346: OKC_API.set_message(p_app_name => g_app_name,
347: p_msg_name => g_unexpected_error,
348: p_token1 => g_sqlcode_token,
349: p_token1_value => sqlcode,
350: p_token2 => g_sqlerrm_token,

Line 352: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

348: p_token1 => g_sqlcode_token,
349: p_token1_value => sqlcode,
350: p_token2 => g_sqlerrm_token,
351: p_token2_value => sqlerrm);
352: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
353: return x_return_status;
354: END Validate_Attributes;
355: /*+++++++++++++End of hand code +++++++++++++++++*/
356:

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

365: --+++++++++++++++Start handcode +++++++++++++++++++++++++++++++++++
366: ,p_mode IN varchar2 DEFAULT 'UPDATE' -- or 'INSERT'
367: --+++++++++++++++End handcode +++++++++++++++++++++++++++++++++++
368: ) RETURN VARCHAR2 IS
369: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
370: /*-------------Commented in favor of hand code------
371: ------------------------------------
372: -- FUNCTION validate_foreign_keys --
373: ------------------------------------

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

419: LAST_UPDATE_LOGIN
420: FROM Okc_Change_Requests_V
421: WHERE okc_change_requests_v.id = p_id;
422: l_okc_crtv_pk okc_crtv_pk_csr%ROWTYPE;
423: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
424: l_row_notfound BOOLEAN := TRUE;
425: BEGIN
426: IF (p_cprv_rec.CRT_ID IS NOT NULL)
427: THEN

Line 433: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CRT_ID');

429: FETCH okc_crtv_pk_csr INTO l_okc_crtv_pk;
430: l_row_notfound := okc_crtv_pk_csr%NOTFOUND;
431: CLOSE okc_crtv_pk_csr;
432: IF (l_row_notfound) THEN
433: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CRT_ID');
434: RAISE item_not_found_error;
435: END IF;
436: END IF;
437: RETURN (l_return_status);

Line 440: l_return_status := OKC_API.G_RET_STS_ERROR;

436: END IF;
437: RETURN (l_return_status);
438: EXCEPTION
439: WHEN item_not_found_error THEN
440: l_return_status := OKC_API.G_RET_STS_ERROR;
441: RETURN (l_return_status);
442: END validate_foreign_keys;
443: BEGIN
444: l_return_status := validate_foreign_keys (p_cprv_rec);

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

445: RETURN (l_return_status);
446: END Validate_Record;
447: ---------------End of the commented code-----------*/
448: /*+++++++++++++Start of hand code +++++++++++++++++*/
449: x_return_status varchar2(1) := OKC_API.G_RET_STS_SUCCESS;
450: cursor pk_csr is
451: select '!' from okc_change_party_role
452: where cpl_id = p_cprv_rec.cpl_id
453: and crt_id = p_cprv_rec.crt_id;

Line 458: if (p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM

454: l_dummy varchar2(1) := '?';
455: BEGIN
456: if (p_mode = 'INSERT') then
457: --
458: if (p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM
459: and p_cprv_rec.crt_id = OKC_API.G_MISS_NUM )
460: then
461: return x_return_status;
462: end if;

Line 459: and p_cprv_rec.crt_id = OKC_API.G_MISS_NUM )

455: BEGIN
456: if (p_mode = 'INSERT') then
457: --
458: if (p_cprv_rec.cpl_id = OKC_API.G_MISS_NUM
459: and p_cprv_rec.crt_id = OKC_API.G_MISS_NUM )
460: then
461: return x_return_status;
462: end if;
463: --

Line 473: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CPL_ID, CRT_ID');

469: then
470: return x_return_status;
471: end if;
472: --
473: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CPL_ID, CRT_ID');
474: return OKC_API.G_RET_STS_ERROR;
475: else -- other mode than INSERT
476: return x_return_status;
477: end if;

Line 474: return OKC_API.G_RET_STS_ERROR;

470: return x_return_status;
471: end if;
472: --
473: OKC_API.set_message(G_APP_NAME, G_INVALID_VALUE,G_COL_NAME_TOKEN,'CPL_ID, CRT_ID');
474: return OKC_API.G_RET_STS_ERROR;
475: else -- other mode than INSERT
476: return x_return_status;
477: end if;
478: exception

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

477: end if;
478: exception
479: when OTHERS then
480: -- store SQL error message on message stack for caller
481: OKC_API.set_message(p_app_name => g_app_name,
482: p_msg_name => g_unexpected_error,
483: p_token1 => g_sqlcode_token,
484: p_token1_value => sqlcode,
485: p_token2 => g_sqlerrm_token,

Line 487: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

483: p_token1 => g_sqlcode_token,
484: p_token1_value => sqlcode,
485: p_token2 => g_sqlerrm_token,
486: p_token2_value => sqlerrm);
487: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
488: return x_return_status;
489: END Validate_Record;
490: /*+++++++++++++End of hand code +++++++++++++++++*/
491:

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

538: p_cprv_rec IN cprv_rec_type) IS
539:
540: l_api_version CONSTANT NUMBER := 1;
541: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_row';
542: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
543: l_cprv_rec cprv_rec_type := p_cprv_rec;
544: l_cpr_rec cpr_rec_type;
545: BEGIN
546: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

542: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
543: l_cprv_rec cprv_rec_type := p_cprv_rec;
544: l_cpr_rec cpr_rec_type;
545: BEGIN
546: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
547: G_PKG_NAME,
548: p_init_msg_list,
549: l_api_version,
550: p_api_version,

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

549: l_api_version,
550: p_api_version,
551: '_PVT',
552: x_return_status);
553: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
554: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
555: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
556: RAISE OKC_API.G_EXCEPTION_ERROR;
557: END IF;

Line 554: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

550: p_api_version,
551: '_PVT',
552: x_return_status);
553: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
554: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
555: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
556: RAISE OKC_API.G_EXCEPTION_ERROR;
557: END IF;
558: --- Validate all non-missing attributes (Item Level Validation)

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

551: '_PVT',
552: x_return_status);
553: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
554: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
555: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
556: RAISE OKC_API.G_EXCEPTION_ERROR;
557: END IF;
558: --- Validate all non-missing attributes (Item Level Validation)
559: l_return_status := Validate_Attributes(l_cprv_rec);

Line 556: RAISE OKC_API.G_EXCEPTION_ERROR;

552: x_return_status);
553: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
554: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
555: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
556: RAISE OKC_API.G_EXCEPTION_ERROR;
557: END IF;
558: --- Validate all non-missing attributes (Item Level Validation)
559: l_return_status := Validate_Attributes(l_cprv_rec);
560: --- If any errors happen abort API

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

557: END IF;
558: --- Validate all non-missing attributes (Item Level Validation)
559: l_return_status := Validate_Attributes(l_cprv_rec);
560: --- If any errors happen abort API
561: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
562: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
563: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
564: RAISE OKC_API.G_EXCEPTION_ERROR;
565: END IF;

Line 562: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

558: --- Validate all non-missing attributes (Item Level Validation)
559: l_return_status := Validate_Attributes(l_cprv_rec);
560: --- If any errors happen abort API
561: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
562: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
563: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
564: RAISE OKC_API.G_EXCEPTION_ERROR;
565: END IF;
566: l_return_status := Validate_Record(l_cprv_rec);

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

559: l_return_status := Validate_Attributes(l_cprv_rec);
560: --- If any errors happen abort API
561: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
562: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
563: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
564: RAISE OKC_API.G_EXCEPTION_ERROR;
565: END IF;
566: l_return_status := Validate_Record(l_cprv_rec);
567: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 564: RAISE OKC_API.G_EXCEPTION_ERROR;

560: --- If any errors happen abort API
561: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
562: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
563: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
564: RAISE OKC_API.G_EXCEPTION_ERROR;
565: END IF;
566: l_return_status := Validate_Record(l_cprv_rec);
567: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

563: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
564: RAISE OKC_API.G_EXCEPTION_ERROR;
565: END IF;
566: l_return_status := Validate_Record(l_cprv_rec);
567: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
569: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
570: RAISE OKC_API.G_EXCEPTION_ERROR;
571: END IF;

Line 568: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

564: RAISE OKC_API.G_EXCEPTION_ERROR;
565: END IF;
566: l_return_status := Validate_Record(l_cprv_rec);
567: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
569: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
570: RAISE OKC_API.G_EXCEPTION_ERROR;
571: END IF;
572: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

565: END IF;
566: l_return_status := Validate_Record(l_cprv_rec);
567: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
569: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
570: RAISE OKC_API.G_EXCEPTION_ERROR;
571: END IF;
572: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
573: EXCEPTION

Line 570: RAISE OKC_API.G_EXCEPTION_ERROR;

566: l_return_status := Validate_Record(l_cprv_rec);
567: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
568: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
569: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
570: RAISE OKC_API.G_EXCEPTION_ERROR;
571: END IF;
572: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
573: EXCEPTION
574: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

568: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
569: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
570: RAISE OKC_API.G_EXCEPTION_ERROR;
571: END IF;
572: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
573: EXCEPTION
574: WHEN OKC_API.G_EXCEPTION_ERROR THEN
575: x_return_status := OKC_API.HANDLE_EXCEPTIONS
576: (

Line 574: WHEN OKC_API.G_EXCEPTION_ERROR THEN

570: RAISE OKC_API.G_EXCEPTION_ERROR;
571: END IF;
572: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
573: EXCEPTION
574: WHEN OKC_API.G_EXCEPTION_ERROR THEN
575: x_return_status := OKC_API.HANDLE_EXCEPTIONS
576: (
577: l_api_name,
578: G_PKG_NAME,

Line 575: x_return_status := OKC_API.HANDLE_EXCEPTIONS

571: END IF;
572: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
573: EXCEPTION
574: WHEN OKC_API.G_EXCEPTION_ERROR THEN
575: x_return_status := OKC_API.HANDLE_EXCEPTIONS
576: (
577: l_api_name,
578: G_PKG_NAME,
579: 'OKC_API.G_RET_STS_ERROR',

Line 579: 'OKC_API.G_RET_STS_ERROR',

575: x_return_status := OKC_API.HANDLE_EXCEPTIONS
576: (
577: l_api_name,
578: G_PKG_NAME,
579: 'OKC_API.G_RET_STS_ERROR',
580: x_msg_count,
581: x_msg_data,
582: '_PVT'
583: );

Line 584: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

580: x_msg_count,
581: x_msg_data,
582: '_PVT'
583: );
584: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
585: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
586: (
587: l_api_name,
588: G_PKG_NAME,

Line 585: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

581: x_msg_data,
582: '_PVT'
583: );
584: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
585: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
586: (
587: l_api_name,
588: G_PKG_NAME,
589: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 589: 'OKC_API.G_RET_STS_UNEXP_ERROR',

585: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
586: (
587: l_api_name,
588: G_PKG_NAME,
589: 'OKC_API.G_RET_STS_UNEXP_ERROR',
590: x_msg_count,
591: x_msg_data,
592: '_PVT'
593: );

Line 595: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

591: x_msg_data,
592: '_PVT'
593: );
594: WHEN OTHERS THEN
595: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
596: (
597: l_api_name,
598: G_PKG_NAME,
599: 'OTHERS',

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

614: p_cprv_tbl IN cprv_tbl_type) IS
615:
616: l_api_version CONSTANT NUMBER := 1;
617: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
618: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
619: i NUMBER := 0;
620: BEGIN
621: OKC_API.init_msg_list(p_init_msg_list);
622: -- Make sure PL/SQL table has records in it before passing

Line 621: OKC_API.init_msg_list(p_init_msg_list);

617: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
618: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
619: i NUMBER := 0;
620: BEGIN
621: OKC_API.init_msg_list(p_init_msg_list);
622: -- Make sure PL/SQL table has records in it before passing
623: IF (p_cprv_tbl.COUNT > 0) THEN
624: i := p_cprv_tbl.FIRST;
625: LOOP

Line 628: p_init_msg_list => OKC_API.G_FALSE,

624: i := p_cprv_tbl.FIRST;
625: LOOP
626: validate_row (
627: p_api_version => p_api_version,
628: p_init_msg_list => OKC_API.G_FALSE,
629: x_return_status => x_return_status,
630: x_msg_count => x_msg_count,
631: x_msg_data => x_msg_data,
632: p_cprv_rec => p_cprv_tbl(i));

Line 638: WHEN OKC_API.G_EXCEPTION_ERROR THEN

634: i := p_cprv_tbl.NEXT(i);
635: END LOOP;
636: END IF;
637: EXCEPTION
638: WHEN OKC_API.G_EXCEPTION_ERROR THEN
639: x_return_status := OKC_API.HANDLE_EXCEPTIONS
640: (
641: l_api_name,
642: G_PKG_NAME,

Line 639: x_return_status := OKC_API.HANDLE_EXCEPTIONS

635: END LOOP;
636: END IF;
637: EXCEPTION
638: WHEN OKC_API.G_EXCEPTION_ERROR THEN
639: x_return_status := OKC_API.HANDLE_EXCEPTIONS
640: (
641: l_api_name,
642: G_PKG_NAME,
643: 'OKC_API.G_RET_STS_ERROR',

Line 643: 'OKC_API.G_RET_STS_ERROR',

639: x_return_status := OKC_API.HANDLE_EXCEPTIONS
640: (
641: l_api_name,
642: G_PKG_NAME,
643: 'OKC_API.G_RET_STS_ERROR',
644: x_msg_count,
645: x_msg_data,
646: '_PVT'
647: );

Line 648: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

644: x_msg_count,
645: x_msg_data,
646: '_PVT'
647: );
648: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
649: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
650: (
651: l_api_name,
652: G_PKG_NAME,

Line 649: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

645: x_msg_data,
646: '_PVT'
647: );
648: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
649: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
650: (
651: l_api_name,
652: G_PKG_NAME,
653: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 653: 'OKC_API.G_RET_STS_UNEXP_ERROR',

649: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
650: (
651: l_api_name,
652: G_PKG_NAME,
653: 'OKC_API.G_RET_STS_UNEXP_ERROR',
654: x_msg_count,
655: x_msg_data,
656: '_PVT'
657: );

Line 659: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

655: x_msg_data,
656: '_PVT'
657: );
658: WHEN OTHERS THEN
659: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
660: (
661: l_api_name,
662: G_PKG_NAME,
663: 'OTHERS',

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

682: x_cpr_rec OUT NOCOPY cpr_rec_type) IS
683:
684: l_api_version CONSTANT NUMBER := 1;
685: l_api_name CONSTANT VARCHAR2(30) := 'ROLE_insert_row';
686: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
687: l_cpr_rec cpr_rec_type := p_cpr_rec;
688: l_def_cpr_rec cpr_rec_type;
689: ----------------------------------------------
690: -- Set_Attributes for:OKC_CHANGE_PARTY_ROLE --

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

692: FUNCTION Set_Attributes (
693: p_cpr_rec IN cpr_rec_type,
694: x_cpr_rec OUT NOCOPY cpr_rec_type
695: ) RETURN VARCHAR2 IS
696: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
697: BEGIN
698: x_cpr_rec := p_cpr_rec;
699: RETURN(l_return_status);
700: END Set_Attributes;

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

698: x_cpr_rec := p_cpr_rec;
699: RETURN(l_return_status);
700: END Set_Attributes;
701: BEGIN
702: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
703: p_init_msg_list,
704: '_PVT',
705: x_return_status);
706: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

702: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
703: p_init_msg_list,
704: '_PVT',
705: x_return_status);
706: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
707: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
708: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
709: RAISE OKC_API.G_EXCEPTION_ERROR;
710: END IF;

Line 707: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

703: p_init_msg_list,
704: '_PVT',
705: x_return_status);
706: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
707: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
708: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
709: RAISE OKC_API.G_EXCEPTION_ERROR;
710: END IF;
711: --- Setting item attributes

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

704: '_PVT',
705: x_return_status);
706: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
707: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
708: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
709: RAISE OKC_API.G_EXCEPTION_ERROR;
710: END IF;
711: --- Setting item attributes
712: l_return_status := Set_Attributes(

Line 709: RAISE OKC_API.G_EXCEPTION_ERROR;

705: x_return_status);
706: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
707: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
708: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
709: RAISE OKC_API.G_EXCEPTION_ERROR;
710: END IF;
711: --- Setting item attributes
712: l_return_status := Set_Attributes(
713: p_cpr_rec, -- IN

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

712: l_return_status := Set_Attributes(
713: p_cpr_rec, -- IN
714: l_cpr_rec); -- OUT
715: --- If any errors happen abort API
716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;

Line 717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

713: p_cpr_rec, -- IN
714: l_cpr_rec); -- OUT
715: --- If any errors happen abort API
716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: INSERT INTO OKC_CHANGE_PARTY_ROLE(

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

714: l_cpr_rec); -- OUT
715: --- If any errors happen abort API
716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: INSERT INTO OKC_CHANGE_PARTY_ROLE(
722: crt_id,

Line 719: RAISE OKC_API.G_EXCEPTION_ERROR;

715: --- If any errors happen abort API
716: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: RAISE OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: INSERT INTO OKC_CHANGE_PARTY_ROLE(
722: crt_id,
723: cpl_id,

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

739: l_cpr_rec.acceptance_date,
740: l_cpr_rec.last_update_login);
741: -- Set OUT values
742: x_cpr_rec := l_cpr_rec;
743: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
744: EXCEPTION
745: WHEN OKC_API.G_EXCEPTION_ERROR THEN
746: x_return_status := OKC_API.HANDLE_EXCEPTIONS
747: (

Line 745: WHEN OKC_API.G_EXCEPTION_ERROR THEN

741: -- Set OUT values
742: x_cpr_rec := l_cpr_rec;
743: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
744: EXCEPTION
745: WHEN OKC_API.G_EXCEPTION_ERROR THEN
746: x_return_status := OKC_API.HANDLE_EXCEPTIONS
747: (
748: l_api_name,
749: G_PKG_NAME,

Line 746: x_return_status := OKC_API.HANDLE_EXCEPTIONS

742: x_cpr_rec := l_cpr_rec;
743: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
744: EXCEPTION
745: WHEN OKC_API.G_EXCEPTION_ERROR THEN
746: x_return_status := OKC_API.HANDLE_EXCEPTIONS
747: (
748: l_api_name,
749: G_PKG_NAME,
750: 'OKC_API.G_RET_STS_ERROR',

Line 750: 'OKC_API.G_RET_STS_ERROR',

746: x_return_status := OKC_API.HANDLE_EXCEPTIONS
747: (
748: l_api_name,
749: G_PKG_NAME,
750: 'OKC_API.G_RET_STS_ERROR',
751: x_msg_count,
752: x_msg_data,
753: '_PVT'
754: );

Line 755: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

751: x_msg_count,
752: x_msg_data,
753: '_PVT'
754: );
755: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
756: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
757: (
758: l_api_name,
759: G_PKG_NAME,

Line 756: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

752: x_msg_data,
753: '_PVT'
754: );
755: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
756: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
757: (
758: l_api_name,
759: G_PKG_NAME,
760: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 760: 'OKC_API.G_RET_STS_UNEXP_ERROR',

756: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
757: (
758: l_api_name,
759: G_PKG_NAME,
760: 'OKC_API.G_RET_STS_UNEXP_ERROR',
761: x_msg_count,
762: x_msg_data,
763: '_PVT'
764: );

Line 766: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

762: x_msg_data,
763: '_PVT'
764: );
765: WHEN OTHERS THEN
766: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
767: (
768: l_api_name,
769: G_PKG_NAME,
770: 'OTHERS',

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

786: x_cprv_rec OUT NOCOPY cprv_rec_type) IS
787:
788: l_api_version CONSTANT NUMBER := 1;
789: l_api_name CONSTANT VARCHAR2(30) := 'V_insert_row';
790: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
791: l_cprv_rec cprv_rec_type;
792: l_def_cprv_rec cprv_rec_type;
793: l_cpr_rec cpr_rec_type;
794: lx_cpr_rec cpr_rec_type;

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

813: FUNCTION Set_Attributes (
814: p_cprv_rec IN cprv_rec_type,
815: x_cprv_rec OUT NOCOPY cprv_rec_type
816: ) RETURN VARCHAR2 IS
817: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
818: BEGIN
819: x_cprv_rec := p_cprv_rec;
820: x_cprv_rec.OBJECT_VERSION_NUMBER := 1;
821: RETURN(l_return_status);

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

820: x_cprv_rec.OBJECT_VERSION_NUMBER := 1;
821: RETURN(l_return_status);
822: END Set_Attributes;
823: BEGIN
824: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
825: G_PKG_NAME,
826: p_init_msg_list,
827: l_api_version,
828: p_api_version,

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

827: l_api_version,
828: p_api_version,
829: '_PVT',
830: x_return_status);
831: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
832: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
833: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
834: RAISE OKC_API.G_EXCEPTION_ERROR;
835: END IF;

Line 832: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

828: p_api_version,
829: '_PVT',
830: x_return_status);
831: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
832: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
833: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
834: RAISE OKC_API.G_EXCEPTION_ERROR;
835: END IF;
836: l_cprv_rec := null_out_defaults(p_cprv_rec);

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

829: '_PVT',
830: x_return_status);
831: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
832: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
833: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
834: RAISE OKC_API.G_EXCEPTION_ERROR;
835: END IF;
836: l_cprv_rec := null_out_defaults(p_cprv_rec);
837: --- Setting item attributes

Line 834: RAISE OKC_API.G_EXCEPTION_ERROR;

830: x_return_status);
831: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
832: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
833: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
834: RAISE OKC_API.G_EXCEPTION_ERROR;
835: END IF;
836: l_cprv_rec := null_out_defaults(p_cprv_rec);
837: --- Setting item attributes
838: l_return_status := Set_Attributes(

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

838: l_return_status := Set_Attributes(
839: l_cprv_rec, -- IN
840: l_def_cprv_rec); -- OUT
841: --- If any errors happen abort API
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;

Line 843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

839: l_cprv_rec, -- IN
840: l_def_cprv_rec); -- OUT
841: --- If any errors happen abort API
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;
847: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);

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

840: l_def_cprv_rec); -- OUT
841: --- If any errors happen abort API
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;
847: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);
848: --- Validate all non-missing attributes (Item Level Validation)

Line 845: RAISE OKC_API.G_EXCEPTION_ERROR;

841: --- If any errors happen abort API
842: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
843: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
844: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
845: RAISE OKC_API.G_EXCEPTION_ERROR;
846: END IF;
847: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);
848: --- Validate all non-missing attributes (Item Level Validation)
849: l_return_status := Validate_Attributes(l_def_cprv_rec);

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

847: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);
848: --- Validate all non-missing attributes (Item Level Validation)
849: l_return_status := Validate_Attributes(l_def_cprv_rec);
850: --- If any errors happen abort API
851: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
852: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
853: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
854: RAISE OKC_API.G_EXCEPTION_ERROR;
855: END IF;

Line 852: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

848: --- Validate all non-missing attributes (Item Level Validation)
849: l_return_status := Validate_Attributes(l_def_cprv_rec);
850: --- If any errors happen abort API
851: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
852: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
853: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
854: RAISE OKC_API.G_EXCEPTION_ERROR;
855: END IF;
856: /*------------------------commented in favor of hand code-----------

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

849: l_return_status := Validate_Attributes(l_def_cprv_rec);
850: --- If any errors happen abort API
851: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
852: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
853: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
854: RAISE OKC_API.G_EXCEPTION_ERROR;
855: END IF;
856: /*------------------------commented in favor of hand code-----------
857: l_return_status := Validate_Record(l_def_cprv_rec);

Line 854: RAISE OKC_API.G_EXCEPTION_ERROR;

850: --- If any errors happen abort API
851: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
852: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
853: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
854: RAISE OKC_API.G_EXCEPTION_ERROR;
855: END IF;
856: /*------------------------commented in favor of hand code-----------
857: l_return_status := Validate_Record(l_def_cprv_rec);
858: ------------------------commented in favor of hand code-----------*/

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

858: ------------------------commented in favor of hand code-----------*/
859: --++++++++++++++++++++++Hand code start+++++++++++++++++++++++++++++
860: l_return_status := Validate_Record(l_def_cprv_rec,'INSERT');
861: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
862: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
863: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
864: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
865: RAISE OKC_API.G_EXCEPTION_ERROR;
866: END IF;

Line 863: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

859: --++++++++++++++++++++++Hand code start+++++++++++++++++++++++++++++
860: l_return_status := Validate_Record(l_def_cprv_rec,'INSERT');
861: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
862: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
863: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
864: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
865: RAISE OKC_API.G_EXCEPTION_ERROR;
866: END IF;
867: --------------------------------------

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

860: l_return_status := Validate_Record(l_def_cprv_rec,'INSERT');
861: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
862: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
863: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
864: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
865: RAISE OKC_API.G_EXCEPTION_ERROR;
866: END IF;
867: --------------------------------------
868: -- Move VIEW record to "Child" records

Line 865: RAISE OKC_API.G_EXCEPTION_ERROR;

861: --++++++++++++++++++++++Hand code end+++++++++++++++++++++++++++++
862: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
863: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
864: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
865: RAISE OKC_API.G_EXCEPTION_ERROR;
866: END IF;
867: --------------------------------------
868: -- Move VIEW record to "Child" records
869: --------------------------------------

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

878: x_msg_data,
879: l_cpr_rec,
880: lx_cpr_rec
881: );
882: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
883: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
884: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
885: RAISE OKC_API.G_EXCEPTION_ERROR;
886: END IF;

Line 883: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

879: l_cpr_rec,
880: lx_cpr_rec
881: );
882: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
883: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
884: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
885: RAISE OKC_API.G_EXCEPTION_ERROR;
886: END IF;
887: migrate(lx_cpr_rec, l_def_cprv_rec);

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

880: lx_cpr_rec
881: );
882: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
883: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
884: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
885: RAISE OKC_API.G_EXCEPTION_ERROR;
886: END IF;
887: migrate(lx_cpr_rec, l_def_cprv_rec);
888: -- Set OUT values

Line 885: RAISE OKC_API.G_EXCEPTION_ERROR;

881: );
882: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
883: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
884: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
885: RAISE OKC_API.G_EXCEPTION_ERROR;
886: END IF;
887: migrate(lx_cpr_rec, l_def_cprv_rec);
888: -- Set OUT values
889: x_cprv_rec := l_def_cprv_rec;

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

886: END IF;
887: migrate(lx_cpr_rec, l_def_cprv_rec);
888: -- Set OUT values
889: x_cprv_rec := l_def_cprv_rec;
890: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
891: EXCEPTION
892: WHEN OKC_API.G_EXCEPTION_ERROR THEN
893: x_return_status := OKC_API.HANDLE_EXCEPTIONS
894: (

Line 892: WHEN OKC_API.G_EXCEPTION_ERROR THEN

888: -- Set OUT values
889: x_cprv_rec := l_def_cprv_rec;
890: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
891: EXCEPTION
892: WHEN OKC_API.G_EXCEPTION_ERROR THEN
893: x_return_status := OKC_API.HANDLE_EXCEPTIONS
894: (
895: l_api_name,
896: G_PKG_NAME,

Line 893: x_return_status := OKC_API.HANDLE_EXCEPTIONS

889: x_cprv_rec := l_def_cprv_rec;
890: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
891: EXCEPTION
892: WHEN OKC_API.G_EXCEPTION_ERROR THEN
893: x_return_status := OKC_API.HANDLE_EXCEPTIONS
894: (
895: l_api_name,
896: G_PKG_NAME,
897: 'OKC_API.G_RET_STS_ERROR',

Line 897: 'OKC_API.G_RET_STS_ERROR',

893: x_return_status := OKC_API.HANDLE_EXCEPTIONS
894: (
895: l_api_name,
896: G_PKG_NAME,
897: 'OKC_API.G_RET_STS_ERROR',
898: x_msg_count,
899: x_msg_data,
900: '_PVT'
901: );

Line 902: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

898: x_msg_count,
899: x_msg_data,
900: '_PVT'
901: );
902: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
903: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
904: (
905: l_api_name,
906: G_PKG_NAME,

Line 903: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

899: x_msg_data,
900: '_PVT'
901: );
902: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
903: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
904: (
905: l_api_name,
906: G_PKG_NAME,
907: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 907: 'OKC_API.G_RET_STS_UNEXP_ERROR',

903: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
904: (
905: l_api_name,
906: G_PKG_NAME,
907: 'OKC_API.G_RET_STS_UNEXP_ERROR',
908: x_msg_count,
909: x_msg_data,
910: '_PVT'
911: );

Line 913: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

909: x_msg_data,
910: '_PVT'
911: );
912: WHEN OTHERS THEN
913: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
914: (
915: l_api_name,
916: G_PKG_NAME,
917: 'OTHERS',

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

933: x_cprv_tbl OUT NOCOPY cprv_tbl_type) IS
934:
935: l_api_version CONSTANT NUMBER := 1;
936: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
937: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
938: i NUMBER := 0;
939: BEGIN
940: OKC_API.init_msg_list(p_init_msg_list);
941: -- Make sure PL/SQL table has records in it before passing

Line 940: OKC_API.init_msg_list(p_init_msg_list);

936: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
937: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
938: i NUMBER := 0;
939: BEGIN
940: OKC_API.init_msg_list(p_init_msg_list);
941: -- Make sure PL/SQL table has records in it before passing
942: IF (p_cprv_tbl.COUNT > 0) THEN
943: i := p_cprv_tbl.FIRST;
944: LOOP

Line 947: p_init_msg_list => OKC_API.G_FALSE,

943: i := p_cprv_tbl.FIRST;
944: LOOP
945: insert_row (
946: p_api_version => p_api_version,
947: p_init_msg_list => OKC_API.G_FALSE,
948: x_return_status => x_return_status,
949: x_msg_count => x_msg_count,
950: x_msg_data => x_msg_data,
951: p_cprv_rec => p_cprv_tbl(i),

Line 958: WHEN OKC_API.G_EXCEPTION_ERROR THEN

954: i := p_cprv_tbl.NEXT(i);
955: END LOOP;
956: END IF;
957: EXCEPTION
958: WHEN OKC_API.G_EXCEPTION_ERROR THEN
959: x_return_status := OKC_API.HANDLE_EXCEPTIONS
960: (
961: l_api_name,
962: G_PKG_NAME,

Line 959: x_return_status := OKC_API.HANDLE_EXCEPTIONS

955: END LOOP;
956: END IF;
957: EXCEPTION
958: WHEN OKC_API.G_EXCEPTION_ERROR THEN
959: x_return_status := OKC_API.HANDLE_EXCEPTIONS
960: (
961: l_api_name,
962: G_PKG_NAME,
963: 'OKC_API.G_RET_STS_ERROR',

Line 963: 'OKC_API.G_RET_STS_ERROR',

959: x_return_status := OKC_API.HANDLE_EXCEPTIONS
960: (
961: l_api_name,
962: G_PKG_NAME,
963: 'OKC_API.G_RET_STS_ERROR',
964: x_msg_count,
965: x_msg_data,
966: '_PVT'
967: );

Line 968: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

964: x_msg_count,
965: x_msg_data,
966: '_PVT'
967: );
968: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
969: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
970: (
971: l_api_name,
972: G_PKG_NAME,

Line 969: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

965: x_msg_data,
966: '_PVT'
967: );
968: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
969: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
970: (
971: l_api_name,
972: G_PKG_NAME,
973: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 973: 'OKC_API.G_RET_STS_UNEXP_ERROR',

969: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
970: (
971: l_api_name,
972: G_PKG_NAME,
973: 'OKC_API.G_RET_STS_UNEXP_ERROR',
974: x_msg_count,
975: x_msg_data,
976: '_PVT'
977: );

Line 979: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

975: x_msg_data,
976: '_PVT'
977: );
978: WHEN OTHERS THEN
979: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
980: (
981: l_api_name,
982: G_PKG_NAME,
983: 'OTHERS',

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

1016: WHERE CRT_ID = p_cpr_rec.crt_id
1017: AND CPL_ID = p_cpr_rec.cpl_id;
1018: l_api_version CONSTANT NUMBER := 1;
1019: l_api_name CONSTANT VARCHAR2(30) := 'ROLE_lock_row';
1020: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1021: l_object_version_number OKC_CHANGE_PARTY_ROLE.OBJECT_VERSION_NUMBER%TYPE;
1022: lc_object_version_number OKC_CHANGE_PARTY_ROLE.OBJECT_VERSION_NUMBER%TYPE;
1023: l_row_notfound BOOLEAN := FALSE;
1024: lc_row_notfound BOOLEAN := FALSE;

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

1022: lc_object_version_number OKC_CHANGE_PARTY_ROLE.OBJECT_VERSION_NUMBER%TYPE;
1023: l_row_notfound BOOLEAN := FALSE;
1024: lc_row_notfound BOOLEAN := FALSE;
1025: BEGIN
1026: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1027: p_init_msg_list,
1028: '_PVT',
1029: x_return_status);
1030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1026: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1027: p_init_msg_list,
1028: '_PVT',
1029: x_return_status);
1030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1033: RAISE OKC_API.G_EXCEPTION_ERROR;
1034: END IF;

Line 1031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1027: p_init_msg_list,
1028: '_PVT',
1029: x_return_status);
1030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1033: RAISE OKC_API.G_EXCEPTION_ERROR;
1034: END IF;
1035: BEGIN

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

1028: '_PVT',
1029: x_return_status);
1030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1033: RAISE OKC_API.G_EXCEPTION_ERROR;
1034: END IF;
1035: BEGIN
1036: OPEN lock_csr(p_cpr_rec);

Line 1033: RAISE OKC_API.G_EXCEPTION_ERROR;

1029: x_return_status);
1030: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1031: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1032: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1033: RAISE OKC_API.G_EXCEPTION_ERROR;
1034: END IF;
1035: BEGIN
1036: OPEN lock_csr(p_cpr_rec);
1037: FETCH lock_csr INTO l_object_version_number;

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

1041: WHEN E_Resource_Busy THEN
1042: IF (lock_csr%ISOPEN) THEN
1043: CLOSE lock_csr;
1044: END IF;
1045: OKC_API.set_message(G_FND_APP,G_FORM_UNABLE_TO_RESERVE_REC);
1046: RAISE APP_EXCEPTIONS.RECORD_LOCK_EXCEPTION;
1047: END;
1048:
1049: IF ( l_row_notfound ) THEN

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

1052: lc_row_notfound := lchk_csr%NOTFOUND;
1053: CLOSE lchk_csr;
1054: END IF;
1055: IF (lc_row_notfound) THEN
1056: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1057: RAISE OKC_API.G_EXCEPTION_ERROR;
1058: ELSIF lc_object_version_number > p_cpr_rec.object_version_number THEN
1059: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1060: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1057: RAISE OKC_API.G_EXCEPTION_ERROR;

1053: CLOSE lchk_csr;
1054: END IF;
1055: IF (lc_row_notfound) THEN
1056: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1057: RAISE OKC_API.G_EXCEPTION_ERROR;
1058: ELSIF lc_object_version_number > p_cpr_rec.object_version_number THEN
1059: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1060: RAISE OKC_API.G_EXCEPTION_ERROR;
1061: ELSIF lc_object_version_number <> p_cpr_rec.object_version_number THEN

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

1055: IF (lc_row_notfound) THEN
1056: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1057: RAISE OKC_API.G_EXCEPTION_ERROR;
1058: ELSIF lc_object_version_number > p_cpr_rec.object_version_number THEN
1059: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1060: RAISE OKC_API.G_EXCEPTION_ERROR;
1061: ELSIF lc_object_version_number <> p_cpr_rec.object_version_number THEN
1062: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1063: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1060: RAISE OKC_API.G_EXCEPTION_ERROR;

1056: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_DELETED);
1057: RAISE OKC_API.G_EXCEPTION_ERROR;
1058: ELSIF lc_object_version_number > p_cpr_rec.object_version_number THEN
1059: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1060: RAISE OKC_API.G_EXCEPTION_ERROR;
1061: ELSIF lc_object_version_number <> p_cpr_rec.object_version_number THEN
1062: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1063: RAISE OKC_API.G_EXCEPTION_ERROR;
1064: ELSIF lc_object_version_number = -1 THEN

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

1058: ELSIF lc_object_version_number > p_cpr_rec.object_version_number THEN
1059: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1060: RAISE OKC_API.G_EXCEPTION_ERROR;
1061: ELSIF lc_object_version_number <> p_cpr_rec.object_version_number THEN
1062: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1063: RAISE OKC_API.G_EXCEPTION_ERROR;
1064: ELSIF lc_object_version_number = -1 THEN
1065: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1066: RAISE OKC_API.G_EXCEPTION_ERROR;

Line 1063: RAISE OKC_API.G_EXCEPTION_ERROR;

1059: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1060: RAISE OKC_API.G_EXCEPTION_ERROR;
1061: ELSIF lc_object_version_number <> p_cpr_rec.object_version_number THEN
1062: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1063: RAISE OKC_API.G_EXCEPTION_ERROR;
1064: ELSIF lc_object_version_number = -1 THEN
1065: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1066: RAISE OKC_API.G_EXCEPTION_ERROR;
1067: END IF;

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

1061: ELSIF lc_object_version_number <> p_cpr_rec.object_version_number THEN
1062: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1063: RAISE OKC_API.G_EXCEPTION_ERROR;
1064: ELSIF lc_object_version_number = -1 THEN
1065: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1066: RAISE OKC_API.G_EXCEPTION_ERROR;
1067: END IF;
1068: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1069: EXCEPTION

Line 1066: RAISE OKC_API.G_EXCEPTION_ERROR;

1062: OKC_API.set_message(G_FND_APP,G_FORM_RECORD_CHANGED);
1063: RAISE OKC_API.G_EXCEPTION_ERROR;
1064: ELSIF lc_object_version_number = -1 THEN
1065: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1066: RAISE OKC_API.G_EXCEPTION_ERROR;
1067: END IF;
1068: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1069: EXCEPTION
1070: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1064: ELSIF lc_object_version_number = -1 THEN
1065: OKC_API.set_message(G_APP_NAME,G_RECORD_LOGICALLY_DELETED);
1066: RAISE OKC_API.G_EXCEPTION_ERROR;
1067: END IF;
1068: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1069: EXCEPTION
1070: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1071: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1072: (

Line 1070: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1066: RAISE OKC_API.G_EXCEPTION_ERROR;
1067: END IF;
1068: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1069: EXCEPTION
1070: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1071: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1072: (
1073: l_api_name,
1074: G_PKG_NAME,

Line 1071: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1067: END IF;
1068: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1069: EXCEPTION
1070: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1071: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1072: (
1073: l_api_name,
1074: G_PKG_NAME,
1075: 'OKC_API.G_RET_STS_ERROR',

Line 1075: 'OKC_API.G_RET_STS_ERROR',

1071: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1072: (
1073: l_api_name,
1074: G_PKG_NAME,
1075: 'OKC_API.G_RET_STS_ERROR',
1076: x_msg_count,
1077: x_msg_data,
1078: '_PVT'
1079: );

Line 1080: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1076: x_msg_count,
1077: x_msg_data,
1078: '_PVT'
1079: );
1080: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1081: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1082: (
1083: l_api_name,
1084: G_PKG_NAME,

Line 1081: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1077: x_msg_data,
1078: '_PVT'
1079: );
1080: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1081: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1082: (
1083: l_api_name,
1084: G_PKG_NAME,
1085: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1085: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1081: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1082: (
1083: l_api_name,
1084: G_PKG_NAME,
1085: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1086: x_msg_count,
1087: x_msg_data,
1088: '_PVT'
1089: );

Line 1091: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1087: x_msg_data,
1088: '_PVT'
1089: );
1090: WHEN OTHERS THEN
1091: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1092: (
1093: l_api_name,
1094: G_PKG_NAME,
1095: 'OTHERS',

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

1110: p_cprv_rec IN cprv_rec_type) IS
1111:
1112: l_api_version CONSTANT NUMBER := 1;
1113: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
1114: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1115: l_cpr_rec cpr_rec_type;
1116: BEGIN
1117: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1118: G_PKG_NAME,

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

1113: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
1114: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1115: l_cpr_rec cpr_rec_type;
1116: BEGIN
1117: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1118: G_PKG_NAME,
1119: p_init_msg_list,
1120: l_api_version,
1121: p_api_version,

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

1120: l_api_version,
1121: p_api_version,
1122: '_PVT',
1123: x_return_status);
1124: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1125: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1126: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1127: RAISE OKC_API.G_EXCEPTION_ERROR;
1128: END IF;

Line 1125: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1121: p_api_version,
1122: '_PVT',
1123: x_return_status);
1124: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1125: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1126: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1127: RAISE OKC_API.G_EXCEPTION_ERROR;
1128: END IF;
1129: --------------------------------------

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

1122: '_PVT',
1123: x_return_status);
1124: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1125: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1126: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1127: RAISE OKC_API.G_EXCEPTION_ERROR;
1128: END IF;
1129: --------------------------------------
1130: -- Move VIEW record to "Child" records

Line 1127: RAISE OKC_API.G_EXCEPTION_ERROR;

1123: x_return_status);
1124: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1125: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1126: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1127: RAISE OKC_API.G_EXCEPTION_ERROR;
1128: END IF;
1129: --------------------------------------
1130: -- Move VIEW record to "Child" records
1131: --------------------------------------

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

1139: x_msg_count,
1140: x_msg_data,
1141: l_cpr_rec
1142: );
1143: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1144: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1145: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1146: RAISE OKC_API.G_EXCEPTION_ERROR;
1147: END IF;

Line 1144: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1140: x_msg_data,
1141: l_cpr_rec
1142: );
1143: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1144: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1145: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1146: RAISE OKC_API.G_EXCEPTION_ERROR;
1147: END IF;
1148: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1141: l_cpr_rec
1142: );
1143: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1144: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1145: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1146: RAISE OKC_API.G_EXCEPTION_ERROR;
1147: END IF;
1148: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1149: EXCEPTION

Line 1146: RAISE OKC_API.G_EXCEPTION_ERROR;

1142: );
1143: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1144: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1145: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1146: RAISE OKC_API.G_EXCEPTION_ERROR;
1147: END IF;
1148: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1149: EXCEPTION
1150: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1144: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1145: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1146: RAISE OKC_API.G_EXCEPTION_ERROR;
1147: END IF;
1148: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1149: EXCEPTION
1150: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1151: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1152: (

Line 1150: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1146: RAISE OKC_API.G_EXCEPTION_ERROR;
1147: END IF;
1148: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1149: EXCEPTION
1150: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1151: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1152: (
1153: l_api_name,
1154: G_PKG_NAME,

Line 1151: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1147: END IF;
1148: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1149: EXCEPTION
1150: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1151: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1152: (
1153: l_api_name,
1154: G_PKG_NAME,
1155: 'OKC_API.G_RET_STS_ERROR',

Line 1155: 'OKC_API.G_RET_STS_ERROR',

1151: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1152: (
1153: l_api_name,
1154: G_PKG_NAME,
1155: 'OKC_API.G_RET_STS_ERROR',
1156: x_msg_count,
1157: x_msg_data,
1158: '_PVT'
1159: );

Line 1160: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1156: x_msg_count,
1157: x_msg_data,
1158: '_PVT'
1159: );
1160: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1161: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1162: (
1163: l_api_name,
1164: G_PKG_NAME,

Line 1161: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1157: x_msg_data,
1158: '_PVT'
1159: );
1160: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1161: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1162: (
1163: l_api_name,
1164: G_PKG_NAME,
1165: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1165: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1161: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1162: (
1163: l_api_name,
1164: G_PKG_NAME,
1165: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1166: x_msg_count,
1167: x_msg_data,
1168: '_PVT'
1169: );

Line 1171: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1167: x_msg_data,
1168: '_PVT'
1169: );
1170: WHEN OTHERS THEN
1171: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1172: (
1173: l_api_name,
1174: G_PKG_NAME,
1175: 'OTHERS',

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

1190: p_cprv_tbl IN cprv_tbl_type) IS
1191:
1192: l_api_version CONSTANT NUMBER := 1;
1193: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
1194: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1195: i NUMBER := 0;
1196: BEGIN
1197: OKC_API.init_msg_list(p_init_msg_list);
1198: -- Make sure PL/SQL table has records in it before passing

Line 1197: OKC_API.init_msg_list(p_init_msg_list);

1193: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
1194: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1195: i NUMBER := 0;
1196: BEGIN
1197: OKC_API.init_msg_list(p_init_msg_list);
1198: -- Make sure PL/SQL table has records in it before passing
1199: IF (p_cprv_tbl.COUNT > 0) THEN
1200: i := p_cprv_tbl.FIRST;
1201: LOOP

Line 1204: p_init_msg_list => OKC_API.G_FALSE,

1200: i := p_cprv_tbl.FIRST;
1201: LOOP
1202: lock_row (
1203: p_api_version => p_api_version,
1204: p_init_msg_list => OKC_API.G_FALSE,
1205: x_return_status => x_return_status,
1206: x_msg_count => x_msg_count,
1207: x_msg_data => x_msg_data,
1208: p_cprv_rec => p_cprv_tbl(i));

Line 1214: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1210: i := p_cprv_tbl.NEXT(i);
1211: END LOOP;
1212: END IF;
1213: EXCEPTION
1214: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1215: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1216: (
1217: l_api_name,
1218: G_PKG_NAME,

Line 1215: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1211: END LOOP;
1212: END IF;
1213: EXCEPTION
1214: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1215: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1216: (
1217: l_api_name,
1218: G_PKG_NAME,
1219: 'OKC_API.G_RET_STS_ERROR',

Line 1219: 'OKC_API.G_RET_STS_ERROR',

1215: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1216: (
1217: l_api_name,
1218: G_PKG_NAME,
1219: 'OKC_API.G_RET_STS_ERROR',
1220: x_msg_count,
1221: x_msg_data,
1222: '_PVT'
1223: );

Line 1224: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 1225: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1221: x_msg_data,
1222: '_PVT'
1223: );
1224: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1225: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1226: (
1227: l_api_name,
1228: G_PKG_NAME,
1229: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1229: 'OKC_API.G_RET_STS_UNEXP_ERROR',

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

Line 1235: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1231: x_msg_data,
1232: '_PVT'
1233: );
1234: WHEN OTHERS THEN
1235: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1236: (
1237: l_api_name,
1238: G_PKG_NAME,
1239: 'OTHERS',

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

1258: x_cpr_rec OUT NOCOPY cpr_rec_type) IS
1259:
1260: l_api_version CONSTANT NUMBER := 1;
1261: l_api_name CONSTANT VARCHAR2(30) := 'ROLE_update_row';
1262: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1263: l_cpr_rec cpr_rec_type := p_cpr_rec;
1264: l_def_cpr_rec cpr_rec_type;
1265: l_row_notfound BOOLEAN := TRUE;
1266: ----------------------------------

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

1271: x_cpr_rec OUT NOCOPY cpr_rec_type
1272: ) RETURN VARCHAR2 IS
1273: l_cpr_rec cpr_rec_type;
1274: l_row_notfound BOOLEAN := TRUE;
1275: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1276: BEGIN
1277: x_cpr_rec := p_cpr_rec;
1278: -- Get current database values
1279: l_cpr_rec := get_rec(p_cpr_rec, l_row_notfound);

Line 1281: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1277: x_cpr_rec := p_cpr_rec;
1278: -- Get current database values
1279: l_cpr_rec := get_rec(p_cpr_rec, l_row_notfound);
1280: IF (l_row_notfound) THEN
1281: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1282: END IF;
1283: IF (x_cpr_rec.crt_id = OKC_API.G_MISS_NUM)
1284: THEN
1285: x_cpr_rec.crt_id := l_cpr_rec.crt_id;

Line 1283: IF (x_cpr_rec.crt_id = OKC_API.G_MISS_NUM)

1279: l_cpr_rec := get_rec(p_cpr_rec, l_row_notfound);
1280: IF (l_row_notfound) THEN
1281: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1282: END IF;
1283: IF (x_cpr_rec.crt_id = OKC_API.G_MISS_NUM)
1284: THEN
1285: x_cpr_rec.crt_id := l_cpr_rec.crt_id;
1286: END IF;
1287: IF (x_cpr_rec.cpl_id = OKC_API.G_MISS_NUM)

Line 1287: IF (x_cpr_rec.cpl_id = OKC_API.G_MISS_NUM)

1283: IF (x_cpr_rec.crt_id = OKC_API.G_MISS_NUM)
1284: THEN
1285: x_cpr_rec.crt_id := l_cpr_rec.crt_id;
1286: END IF;
1287: IF (x_cpr_rec.cpl_id = OKC_API.G_MISS_NUM)
1288: THEN
1289: x_cpr_rec.cpl_id := l_cpr_rec.cpl_id;
1290: END IF;
1291: IF (x_cpr_rec.object_version_number = OKC_API.G_MISS_NUM)

Line 1291: IF (x_cpr_rec.object_version_number = OKC_API.G_MISS_NUM)

1287: IF (x_cpr_rec.cpl_id = OKC_API.G_MISS_NUM)
1288: THEN
1289: x_cpr_rec.cpl_id := l_cpr_rec.cpl_id;
1290: END IF;
1291: IF (x_cpr_rec.object_version_number = OKC_API.G_MISS_NUM)
1292: THEN
1293: x_cpr_rec.object_version_number := l_cpr_rec.object_version_number;
1294: END IF;
1295: IF (x_cpr_rec.created_by = OKC_API.G_MISS_NUM)

Line 1295: IF (x_cpr_rec.created_by = OKC_API.G_MISS_NUM)

1291: IF (x_cpr_rec.object_version_number = OKC_API.G_MISS_NUM)
1292: THEN
1293: x_cpr_rec.object_version_number := l_cpr_rec.object_version_number;
1294: END IF;
1295: IF (x_cpr_rec.created_by = OKC_API.G_MISS_NUM)
1296: THEN
1297: x_cpr_rec.created_by := l_cpr_rec.created_by;
1298: END IF;
1299: IF (x_cpr_rec.creation_date = OKC_API.G_MISS_DATE)

Line 1299: IF (x_cpr_rec.creation_date = OKC_API.G_MISS_DATE)

1295: IF (x_cpr_rec.created_by = OKC_API.G_MISS_NUM)
1296: THEN
1297: x_cpr_rec.created_by := l_cpr_rec.created_by;
1298: END IF;
1299: IF (x_cpr_rec.creation_date = OKC_API.G_MISS_DATE)
1300: THEN
1301: x_cpr_rec.creation_date := l_cpr_rec.creation_date;
1302: END IF;
1303: IF (x_cpr_rec.last_updated_by = OKC_API.G_MISS_NUM)

Line 1303: IF (x_cpr_rec.last_updated_by = OKC_API.G_MISS_NUM)

1299: IF (x_cpr_rec.creation_date = OKC_API.G_MISS_DATE)
1300: THEN
1301: x_cpr_rec.creation_date := l_cpr_rec.creation_date;
1302: END IF;
1303: IF (x_cpr_rec.last_updated_by = OKC_API.G_MISS_NUM)
1304: THEN
1305: x_cpr_rec.last_updated_by := l_cpr_rec.last_updated_by;
1306: END IF;
1307: IF (x_cpr_rec.last_update_date = OKC_API.G_MISS_DATE)

Line 1307: IF (x_cpr_rec.last_update_date = OKC_API.G_MISS_DATE)

1303: IF (x_cpr_rec.last_updated_by = OKC_API.G_MISS_NUM)
1304: THEN
1305: x_cpr_rec.last_updated_by := l_cpr_rec.last_updated_by;
1306: END IF;
1307: IF (x_cpr_rec.last_update_date = OKC_API.G_MISS_DATE)
1308: THEN
1309: x_cpr_rec.last_update_date := l_cpr_rec.last_update_date;
1310: END IF;
1311: IF (x_cpr_rec.acceptance_date = OKC_API.G_MISS_DATE)

Line 1311: IF (x_cpr_rec.acceptance_date = OKC_API.G_MISS_DATE)

1307: IF (x_cpr_rec.last_update_date = OKC_API.G_MISS_DATE)
1308: THEN
1309: x_cpr_rec.last_update_date := l_cpr_rec.last_update_date;
1310: END IF;
1311: IF (x_cpr_rec.acceptance_date = OKC_API.G_MISS_DATE)
1312: THEN
1313: x_cpr_rec.acceptance_date := l_cpr_rec.acceptance_date;
1314: END IF;
1315: IF (x_cpr_rec.last_update_login = OKC_API.G_MISS_NUM)

Line 1315: IF (x_cpr_rec.last_update_login = OKC_API.G_MISS_NUM)

1311: IF (x_cpr_rec.acceptance_date = OKC_API.G_MISS_DATE)
1312: THEN
1313: x_cpr_rec.acceptance_date := l_cpr_rec.acceptance_date;
1314: END IF;
1315: IF (x_cpr_rec.last_update_login = OKC_API.G_MISS_NUM)
1316: THEN
1317: x_cpr_rec.last_update_login := l_cpr_rec.last_update_login;
1318: END IF;
1319: RETURN(l_return_status);

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

1324: FUNCTION Set_Attributes (
1325: p_cpr_rec IN cpr_rec_type,
1326: x_cpr_rec OUT NOCOPY cpr_rec_type
1327: ) RETURN VARCHAR2 IS
1328: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1329: BEGIN
1330: x_cpr_rec := p_cpr_rec;
1331: RETURN(l_return_status);
1332: END Set_Attributes;

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

1330: x_cpr_rec := p_cpr_rec;
1331: RETURN(l_return_status);
1332: END Set_Attributes;
1333: BEGIN
1334: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1335: p_init_msg_list,
1336: '_PVT',
1337: x_return_status);
1338: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1334: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1335: p_init_msg_list,
1336: '_PVT',
1337: x_return_status);
1338: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1339: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1340: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_ERROR;
1342: END IF;

Line 1339: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1335: p_init_msg_list,
1336: '_PVT',
1337: x_return_status);
1338: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1339: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1340: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_ERROR;
1342: END IF;
1343: --- Setting item attributes

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

1336: '_PVT',
1337: x_return_status);
1338: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1339: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1340: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_ERROR;
1342: END IF;
1343: --- Setting item attributes
1344: l_return_status := Set_Attributes(

Line 1341: RAISE OKC_API.G_EXCEPTION_ERROR;

1337: x_return_status);
1338: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1339: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1340: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1341: RAISE OKC_API.G_EXCEPTION_ERROR;
1342: END IF;
1343: --- Setting item attributes
1344: l_return_status := Set_Attributes(
1345: p_cpr_rec, -- IN

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

1344: l_return_status := Set_Attributes(
1345: p_cpr_rec, -- IN
1346: l_cpr_rec); -- OUT
1347: --- If any errors happen abort API
1348: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1349: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1350: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1351: RAISE OKC_API.G_EXCEPTION_ERROR;
1352: END IF;

Line 1349: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1345: p_cpr_rec, -- IN
1346: l_cpr_rec); -- OUT
1347: --- If any errors happen abort API
1348: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1349: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1350: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1351: RAISE OKC_API.G_EXCEPTION_ERROR;
1352: END IF;
1353: l_return_status := populate_new_record(l_cpr_rec, l_def_cpr_rec);

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

1346: l_cpr_rec); -- OUT
1347: --- If any errors happen abort API
1348: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1349: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1350: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1351: RAISE OKC_API.G_EXCEPTION_ERROR;
1352: END IF;
1353: l_return_status := populate_new_record(l_cpr_rec, l_def_cpr_rec);
1354: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1351: RAISE OKC_API.G_EXCEPTION_ERROR;

1347: --- If any errors happen abort API
1348: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1349: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1350: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1351: RAISE OKC_API.G_EXCEPTION_ERROR;
1352: END IF;
1353: l_return_status := populate_new_record(l_cpr_rec, l_def_cpr_rec);
1354: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1355: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

1350: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1351: RAISE OKC_API.G_EXCEPTION_ERROR;
1352: END IF;
1353: l_return_status := populate_new_record(l_cpr_rec, l_def_cpr_rec);
1354: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1355: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1356: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1357: RAISE OKC_API.G_EXCEPTION_ERROR;
1358: END IF;

Line 1355: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1351: RAISE OKC_API.G_EXCEPTION_ERROR;
1352: END IF;
1353: l_return_status := populate_new_record(l_cpr_rec, l_def_cpr_rec);
1354: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1355: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1356: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1357: RAISE OKC_API.G_EXCEPTION_ERROR;
1358: END IF;
1359: UPDATE OKC_CHANGE_PARTY_ROLE

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

1352: END IF;
1353: l_return_status := populate_new_record(l_cpr_rec, l_def_cpr_rec);
1354: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1355: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1356: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1357: RAISE OKC_API.G_EXCEPTION_ERROR;
1358: END IF;
1359: UPDATE OKC_CHANGE_PARTY_ROLE
1360: SET OBJECT_VERSION_NUMBER = l_def_cpr_rec.object_version_number,

Line 1357: RAISE OKC_API.G_EXCEPTION_ERROR;

1353: l_return_status := populate_new_record(l_cpr_rec, l_def_cpr_rec);
1354: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1355: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1356: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1357: RAISE OKC_API.G_EXCEPTION_ERROR;
1358: END IF;
1359: UPDATE OKC_CHANGE_PARTY_ROLE
1360: SET OBJECT_VERSION_NUMBER = l_def_cpr_rec.object_version_number,
1361: CREATED_BY = l_def_cpr_rec.created_by,

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

1367: WHERE CRT_ID = l_def_cpr_rec.crt_id
1368: AND CPL_ID = l_def_cpr_rec.cpl_id;
1369:
1370: x_cpr_rec := l_def_cpr_rec;
1371: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1372: EXCEPTION
1373: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1374: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1375: (

Line 1373: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1369:
1370: x_cpr_rec := l_def_cpr_rec;
1371: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1372: EXCEPTION
1373: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1374: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1375: (
1376: l_api_name,
1377: G_PKG_NAME,

Line 1374: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1370: x_cpr_rec := l_def_cpr_rec;
1371: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1372: EXCEPTION
1373: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1374: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1375: (
1376: l_api_name,
1377: G_PKG_NAME,
1378: 'OKC_API.G_RET_STS_ERROR',

Line 1378: 'OKC_API.G_RET_STS_ERROR',

1374: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1375: (
1376: l_api_name,
1377: G_PKG_NAME,
1378: 'OKC_API.G_RET_STS_ERROR',
1379: x_msg_count,
1380: x_msg_data,
1381: '_PVT'
1382: );

Line 1383: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1379: x_msg_count,
1380: x_msg_data,
1381: '_PVT'
1382: );
1383: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1384: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1385: (
1386: l_api_name,
1387: G_PKG_NAME,

Line 1384: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1380: x_msg_data,
1381: '_PVT'
1382: );
1383: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1384: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1385: (
1386: l_api_name,
1387: G_PKG_NAME,
1388: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1388: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1384: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1385: (
1386: l_api_name,
1387: G_PKG_NAME,
1388: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1389: x_msg_count,
1390: x_msg_data,
1391: '_PVT'
1392: );

Line 1394: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1390: x_msg_data,
1391: '_PVT'
1392: );
1393: WHEN OTHERS THEN
1394: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1395: (
1396: l_api_name,
1397: G_PKG_NAME,
1398: 'OTHERS',

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

1414: x_cprv_rec OUT NOCOPY cprv_rec_type) IS
1415:
1416: l_api_version CONSTANT NUMBER := 1;
1417: l_api_name CONSTANT VARCHAR2(30) := 'V_update_row';
1418: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1419: l_cprv_rec cprv_rec_type := p_cprv_rec;
1420: l_def_cprv_rec cprv_rec_type;
1421: l_cpr_rec cpr_rec_type;
1422: lx_cpr_rec cpr_rec_type;

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

1441: x_cprv_rec OUT NOCOPY cprv_rec_type
1442: ) RETURN VARCHAR2 IS
1443: l_cprv_rec cprv_rec_type;
1444: l_row_notfound BOOLEAN := TRUE;
1445: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1446: BEGIN
1447: x_cprv_rec := p_cprv_rec;
1448: -- Get current database values
1449: l_cprv_rec := get_rec(p_cprv_rec, l_row_notfound);

Line 1451: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1447: x_cprv_rec := p_cprv_rec;
1448: -- Get current database values
1449: l_cprv_rec := get_rec(p_cprv_rec, l_row_notfound);
1450: IF (l_row_notfound) THEN
1451: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1452: END IF;
1453: IF (x_cprv_rec.crt_id = OKC_API.G_MISS_NUM)
1454: THEN
1455: x_cprv_rec.crt_id := l_cprv_rec.crt_id;

Line 1453: IF (x_cprv_rec.crt_id = OKC_API.G_MISS_NUM)

1449: l_cprv_rec := get_rec(p_cprv_rec, l_row_notfound);
1450: IF (l_row_notfound) THEN
1451: l_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1452: END IF;
1453: IF (x_cprv_rec.crt_id = OKC_API.G_MISS_NUM)
1454: THEN
1455: x_cprv_rec.crt_id := l_cprv_rec.crt_id;
1456: END IF;
1457: IF (x_cprv_rec.cpl_id = OKC_API.G_MISS_NUM)

Line 1457: IF (x_cprv_rec.cpl_id = OKC_API.G_MISS_NUM)

1453: IF (x_cprv_rec.crt_id = OKC_API.G_MISS_NUM)
1454: THEN
1455: x_cprv_rec.crt_id := l_cprv_rec.crt_id;
1456: END IF;
1457: IF (x_cprv_rec.cpl_id = OKC_API.G_MISS_NUM)
1458: THEN
1459: x_cprv_rec.cpl_id := l_cprv_rec.cpl_id;
1460: END IF;
1461: IF (x_cprv_rec.object_version_number = OKC_API.G_MISS_NUM)

Line 1461: IF (x_cprv_rec.object_version_number = OKC_API.G_MISS_NUM)

1457: IF (x_cprv_rec.cpl_id = OKC_API.G_MISS_NUM)
1458: THEN
1459: x_cprv_rec.cpl_id := l_cprv_rec.cpl_id;
1460: END IF;
1461: IF (x_cprv_rec.object_version_number = OKC_API.G_MISS_NUM)
1462: THEN
1463: x_cprv_rec.object_version_number := l_cprv_rec.object_version_number;
1464: END IF;
1465: IF (x_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE)

Line 1465: IF (x_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE)

1461: IF (x_cprv_rec.object_version_number = OKC_API.G_MISS_NUM)
1462: THEN
1463: x_cprv_rec.object_version_number := l_cprv_rec.object_version_number;
1464: END IF;
1465: IF (x_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE)
1466: THEN
1467: x_cprv_rec.acceptance_date := l_cprv_rec.acceptance_date;
1468: END IF;
1469: IF (x_cprv_rec.created_by = OKC_API.G_MISS_NUM)

Line 1469: IF (x_cprv_rec.created_by = OKC_API.G_MISS_NUM)

1465: IF (x_cprv_rec.acceptance_date = OKC_API.G_MISS_DATE)
1466: THEN
1467: x_cprv_rec.acceptance_date := l_cprv_rec.acceptance_date;
1468: END IF;
1469: IF (x_cprv_rec.created_by = OKC_API.G_MISS_NUM)
1470: THEN
1471: x_cprv_rec.created_by := l_cprv_rec.created_by;
1472: END IF;
1473: IF (x_cprv_rec.creation_date = OKC_API.G_MISS_DATE)

Line 1473: IF (x_cprv_rec.creation_date = OKC_API.G_MISS_DATE)

1469: IF (x_cprv_rec.created_by = OKC_API.G_MISS_NUM)
1470: THEN
1471: x_cprv_rec.created_by := l_cprv_rec.created_by;
1472: END IF;
1473: IF (x_cprv_rec.creation_date = OKC_API.G_MISS_DATE)
1474: THEN
1475: x_cprv_rec.creation_date := l_cprv_rec.creation_date;
1476: END IF;
1477: IF (x_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM)

Line 1477: IF (x_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM)

1473: IF (x_cprv_rec.creation_date = OKC_API.G_MISS_DATE)
1474: THEN
1475: x_cprv_rec.creation_date := l_cprv_rec.creation_date;
1476: END IF;
1477: IF (x_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM)
1478: THEN
1479: x_cprv_rec.last_updated_by := l_cprv_rec.last_updated_by;
1480: END IF;
1481: IF (x_cprv_rec.last_update_date = OKC_API.G_MISS_DATE)

Line 1481: IF (x_cprv_rec.last_update_date = OKC_API.G_MISS_DATE)

1477: IF (x_cprv_rec.last_updated_by = OKC_API.G_MISS_NUM)
1478: THEN
1479: x_cprv_rec.last_updated_by := l_cprv_rec.last_updated_by;
1480: END IF;
1481: IF (x_cprv_rec.last_update_date = OKC_API.G_MISS_DATE)
1482: THEN
1483: x_cprv_rec.last_update_date := l_cprv_rec.last_update_date;
1484: END IF;
1485: IF (x_cprv_rec.last_update_login = OKC_API.G_MISS_NUM)

Line 1485: IF (x_cprv_rec.last_update_login = OKC_API.G_MISS_NUM)

1481: IF (x_cprv_rec.last_update_date = OKC_API.G_MISS_DATE)
1482: THEN
1483: x_cprv_rec.last_update_date := l_cprv_rec.last_update_date;
1484: END IF;
1485: IF (x_cprv_rec.last_update_login = OKC_API.G_MISS_NUM)
1486: THEN
1487: x_cprv_rec.last_update_login := l_cprv_rec.last_update_login;
1488: END IF;
1489: RETURN(l_return_status);

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

1494: FUNCTION Set_Attributes (
1495: p_cprv_rec IN cprv_rec_type,
1496: x_cprv_rec OUT NOCOPY cprv_rec_type
1497: ) RETURN VARCHAR2 IS
1498: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1499: BEGIN
1500: x_cprv_rec := p_cprv_rec;
1501: x_cprv_rec.OBJECT_VERSION_NUMBER := NVL(x_cprv_rec.OBJECT_VERSION_NUMBER, 0) + 1;
1502: RETURN(l_return_status);

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

1501: x_cprv_rec.OBJECT_VERSION_NUMBER := NVL(x_cprv_rec.OBJECT_VERSION_NUMBER, 0) + 1;
1502: RETURN(l_return_status);
1503: END Set_Attributes;
1504: BEGIN
1505: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1506: G_PKG_NAME,
1507: p_init_msg_list,
1508: l_api_version,
1509: p_api_version,

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

1508: l_api_version,
1509: p_api_version,
1510: '_PVT',
1511: x_return_status);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;

Line 1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1509: p_api_version,
1510: '_PVT',
1511: x_return_status);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;
1517: --- Setting item attributes

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

1510: '_PVT',
1511: x_return_status);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;
1517: --- Setting item attributes
1518: l_return_status := Set_Attributes(

Line 1515: RAISE OKC_API.G_EXCEPTION_ERROR;

1511: x_return_status);
1512: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1513: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1514: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1515: RAISE OKC_API.G_EXCEPTION_ERROR;
1516: END IF;
1517: --- Setting item attributes
1518: l_return_status := Set_Attributes(
1519: p_cprv_rec, -- IN

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

1518: l_return_status := Set_Attributes(
1519: p_cprv_rec, -- IN
1520: l_cprv_rec); -- OUT
1521: --- If any errors happen abort API
1522: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1524: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1525: RAISE OKC_API.G_EXCEPTION_ERROR;
1526: END IF;

Line 1523: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1519: p_cprv_rec, -- IN
1520: l_cprv_rec); -- OUT
1521: --- If any errors happen abort API
1522: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1524: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1525: RAISE OKC_API.G_EXCEPTION_ERROR;
1526: END IF;
1527: l_return_status := populate_new_record(l_cprv_rec, l_def_cprv_rec);

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

1520: l_cprv_rec); -- OUT
1521: --- If any errors happen abort API
1522: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1524: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1525: RAISE OKC_API.G_EXCEPTION_ERROR;
1526: END IF;
1527: l_return_status := populate_new_record(l_cprv_rec, l_def_cprv_rec);
1528: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1525: RAISE OKC_API.G_EXCEPTION_ERROR;

1521: --- If any errors happen abort API
1522: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1524: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1525: RAISE OKC_API.G_EXCEPTION_ERROR;
1526: END IF;
1527: l_return_status := populate_new_record(l_cprv_rec, l_def_cprv_rec);
1528: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1529: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

1524: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1525: RAISE OKC_API.G_EXCEPTION_ERROR;
1526: END IF;
1527: l_return_status := populate_new_record(l_cprv_rec, l_def_cprv_rec);
1528: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1529: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1530: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1531: RAISE OKC_API.G_EXCEPTION_ERROR;
1532: END IF;

Line 1529: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1525: RAISE OKC_API.G_EXCEPTION_ERROR;
1526: END IF;
1527: l_return_status := populate_new_record(l_cprv_rec, l_def_cprv_rec);
1528: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1529: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1530: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1531: RAISE OKC_API.G_EXCEPTION_ERROR;
1532: END IF;
1533: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);

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

1526: END IF;
1527: l_return_status := populate_new_record(l_cprv_rec, l_def_cprv_rec);
1528: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1529: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1530: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1531: RAISE OKC_API.G_EXCEPTION_ERROR;
1532: END IF;
1533: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);
1534: --- Validate all non-missing attributes (Item Level Validation)

Line 1531: RAISE OKC_API.G_EXCEPTION_ERROR;

1527: l_return_status := populate_new_record(l_cprv_rec, l_def_cprv_rec);
1528: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1529: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1530: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1531: RAISE OKC_API.G_EXCEPTION_ERROR;
1532: END IF;
1533: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);
1534: --- Validate all non-missing attributes (Item Level Validation)
1535: l_return_status := Validate_Attributes(l_def_cprv_rec);

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

1533: l_def_cprv_rec := fill_who_columns(l_def_cprv_rec);
1534: --- Validate all non-missing attributes (Item Level Validation)
1535: l_return_status := Validate_Attributes(l_def_cprv_rec);
1536: --- If any errors happen abort API
1537: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1538: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1539: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1540: RAISE OKC_API.G_EXCEPTION_ERROR;
1541: END IF;

Line 1538: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1534: --- Validate all non-missing attributes (Item Level Validation)
1535: l_return_status := Validate_Attributes(l_def_cprv_rec);
1536: --- If any errors happen abort API
1537: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1538: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1539: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1540: RAISE OKC_API.G_EXCEPTION_ERROR;
1541: END IF;
1542: l_return_status := Validate_Record(l_def_cprv_rec);

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

1535: l_return_status := Validate_Attributes(l_def_cprv_rec);
1536: --- If any errors happen abort API
1537: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1538: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1539: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1540: RAISE OKC_API.G_EXCEPTION_ERROR;
1541: END IF;
1542: l_return_status := Validate_Record(l_def_cprv_rec);
1543: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1540: RAISE OKC_API.G_EXCEPTION_ERROR;

1536: --- If any errors happen abort API
1537: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1538: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1539: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1540: RAISE OKC_API.G_EXCEPTION_ERROR;
1541: END IF;
1542: l_return_status := Validate_Record(l_def_cprv_rec);
1543: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1544: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

1539: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1540: RAISE OKC_API.G_EXCEPTION_ERROR;
1541: END IF;
1542: l_return_status := Validate_Record(l_def_cprv_rec);
1543: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1544: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1545: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1546: RAISE OKC_API.G_EXCEPTION_ERROR;
1547: END IF;

Line 1544: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1540: RAISE OKC_API.G_EXCEPTION_ERROR;
1541: END IF;
1542: l_return_status := Validate_Record(l_def_cprv_rec);
1543: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1544: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1545: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1546: RAISE OKC_API.G_EXCEPTION_ERROR;
1547: END IF;
1548:

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

1541: END IF;
1542: l_return_status := Validate_Record(l_def_cprv_rec);
1543: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1544: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1545: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1546: RAISE OKC_API.G_EXCEPTION_ERROR;
1547: END IF;
1548:
1549: --------------------------------------

Line 1546: RAISE OKC_API.G_EXCEPTION_ERROR;

1542: l_return_status := Validate_Record(l_def_cprv_rec);
1543: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1544: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1545: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1546: RAISE OKC_API.G_EXCEPTION_ERROR;
1547: END IF;
1548:
1549: --------------------------------------
1550: -- Move VIEW record to "Child" records

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

1560: x_msg_data,
1561: l_cpr_rec,
1562: lx_cpr_rec
1563: );
1564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1565: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1567: RAISE OKC_API.G_EXCEPTION_ERROR;
1568: END IF;

Line 1565: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1561: l_cpr_rec,
1562: lx_cpr_rec
1563: );
1564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1565: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1567: RAISE OKC_API.G_EXCEPTION_ERROR;
1568: END IF;
1569: migrate(lx_cpr_rec, l_def_cprv_rec);

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

1562: lx_cpr_rec
1563: );
1564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1565: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1567: RAISE OKC_API.G_EXCEPTION_ERROR;
1568: END IF;
1569: migrate(lx_cpr_rec, l_def_cprv_rec);
1570: x_cprv_rec := l_def_cprv_rec;

Line 1567: RAISE OKC_API.G_EXCEPTION_ERROR;

1563: );
1564: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1565: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1566: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1567: RAISE OKC_API.G_EXCEPTION_ERROR;
1568: END IF;
1569: migrate(lx_cpr_rec, l_def_cprv_rec);
1570: x_cprv_rec := l_def_cprv_rec;
1571: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1567: RAISE OKC_API.G_EXCEPTION_ERROR;
1568: END IF;
1569: migrate(lx_cpr_rec, l_def_cprv_rec);
1570: x_cprv_rec := l_def_cprv_rec;
1571: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1572: EXCEPTION
1573: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1574: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1575: (

Line 1573: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1569: migrate(lx_cpr_rec, l_def_cprv_rec);
1570: x_cprv_rec := l_def_cprv_rec;
1571: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1572: EXCEPTION
1573: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1574: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1575: (
1576: l_api_name,
1577: G_PKG_NAME,

Line 1574: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1570: x_cprv_rec := l_def_cprv_rec;
1571: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1572: EXCEPTION
1573: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1574: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1575: (
1576: l_api_name,
1577: G_PKG_NAME,
1578: 'OKC_API.G_RET_STS_ERROR',

Line 1578: 'OKC_API.G_RET_STS_ERROR',

1574: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1575: (
1576: l_api_name,
1577: G_PKG_NAME,
1578: 'OKC_API.G_RET_STS_ERROR',
1579: x_msg_count,
1580: x_msg_data,
1581: '_PVT'
1582: );

Line 1583: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1579: x_msg_count,
1580: x_msg_data,
1581: '_PVT'
1582: );
1583: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1584: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1585: (
1586: l_api_name,
1587: G_PKG_NAME,

Line 1584: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1580: x_msg_data,
1581: '_PVT'
1582: );
1583: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1584: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1585: (
1586: l_api_name,
1587: G_PKG_NAME,
1588: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1588: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1584: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1585: (
1586: l_api_name,
1587: G_PKG_NAME,
1588: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1589: x_msg_count,
1590: x_msg_data,
1591: '_PVT'
1592: );

Line 1594: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1590: x_msg_data,
1591: '_PVT'
1592: );
1593: WHEN OTHERS THEN
1594: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1595: (
1596: l_api_name,
1597: G_PKG_NAME,
1598: 'OTHERS',

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

1614: x_cprv_tbl OUT NOCOPY cprv_tbl_type) IS
1615:
1616: l_api_version CONSTANT NUMBER := 1;
1617: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
1618: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1619: i NUMBER := 0;
1620: BEGIN
1621: OKC_API.init_msg_list(p_init_msg_list);
1622: -- Make sure PL/SQL table has records in it before passing

Line 1621: OKC_API.init_msg_list(p_init_msg_list);

1617: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
1618: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1619: i NUMBER := 0;
1620: BEGIN
1621: OKC_API.init_msg_list(p_init_msg_list);
1622: -- Make sure PL/SQL table has records in it before passing
1623: IF (p_cprv_tbl.COUNT > 0) THEN
1624: i := p_cprv_tbl.FIRST;
1625: LOOP

Line 1628: p_init_msg_list => OKC_API.G_FALSE,

1624: i := p_cprv_tbl.FIRST;
1625: LOOP
1626: update_row (
1627: p_api_version => p_api_version,
1628: p_init_msg_list => OKC_API.G_FALSE,
1629: x_return_status => x_return_status,
1630: x_msg_count => x_msg_count,
1631: x_msg_data => x_msg_data,
1632: p_cprv_rec => p_cprv_tbl(i),

Line 1639: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1635: i := p_cprv_tbl.NEXT(i);
1636: END LOOP;
1637: END IF;
1638: EXCEPTION
1639: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1640: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1641: (
1642: l_api_name,
1643: G_PKG_NAME,

Line 1640: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1636: END LOOP;
1637: END IF;
1638: EXCEPTION
1639: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1640: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1641: (
1642: l_api_name,
1643: G_PKG_NAME,
1644: 'OKC_API.G_RET_STS_ERROR',

Line 1644: 'OKC_API.G_RET_STS_ERROR',

1640: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1641: (
1642: l_api_name,
1643: G_PKG_NAME,
1644: 'OKC_API.G_RET_STS_ERROR',
1645: x_msg_count,
1646: x_msg_data,
1647: '_PVT'
1648: );

Line 1649: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1645: x_msg_count,
1646: x_msg_data,
1647: '_PVT'
1648: );
1649: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1650: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1651: (
1652: l_api_name,
1653: G_PKG_NAME,

Line 1650: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1646: x_msg_data,
1647: '_PVT'
1648: );
1649: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1650: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1651: (
1652: l_api_name,
1653: G_PKG_NAME,
1654: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1654: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1650: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1651: (
1652: l_api_name,
1653: G_PKG_NAME,
1654: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1655: x_msg_count,
1656: x_msg_data,
1657: '_PVT'
1658: );

Line 1660: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1656: x_msg_data,
1657: '_PVT'
1658: );
1659: WHEN OTHERS THEN
1660: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1661: (
1662: l_api_name,
1663: G_PKG_NAME,
1664: 'OTHERS',

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

1682: p_cpr_rec IN cpr_rec_type) IS
1683:
1684: l_api_version CONSTANT NUMBER := 1;
1685: l_api_name CONSTANT VARCHAR2(30) := 'ROLE_delete_row';
1686: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1687: l_cpr_rec cpr_rec_type:= p_cpr_rec;
1688: l_row_notfound BOOLEAN := TRUE;
1689: BEGIN
1690: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1686: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1687: l_cpr_rec cpr_rec_type:= p_cpr_rec;
1688: l_row_notfound BOOLEAN := TRUE;
1689: BEGIN
1690: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1691: p_init_msg_list,
1692: '_PVT',
1693: x_return_status);
1694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1690: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1691: p_init_msg_list,
1692: '_PVT',
1693: x_return_status);
1694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: RAISE OKC_API.G_EXCEPTION_ERROR;
1698: END IF;

Line 1695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1691: p_init_msg_list,
1692: '_PVT',
1693: x_return_status);
1694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: RAISE OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: DELETE FROM OKC_CHANGE_PARTY_ROLE

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

1692: '_PVT',
1693: x_return_status);
1694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: RAISE OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: DELETE FROM OKC_CHANGE_PARTY_ROLE
1700: WHERE CRT_ID = l_cpr_rec.crt_id AND

Line 1697: RAISE OKC_API.G_EXCEPTION_ERROR;

1693: x_return_status);
1694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: RAISE OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: DELETE FROM OKC_CHANGE_PARTY_ROLE
1700: WHERE CRT_ID = l_cpr_rec.crt_id AND
1701: CPL_ID = l_cpr_rec.cpl_id;

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

1699: DELETE FROM OKC_CHANGE_PARTY_ROLE
1700: WHERE CRT_ID = l_cpr_rec.crt_id AND
1701: CPL_ID = l_cpr_rec.cpl_id;
1702:
1703: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1704: EXCEPTION
1705: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1706: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1707: (

Line 1705: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1701: CPL_ID = l_cpr_rec.cpl_id;
1702:
1703: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1704: EXCEPTION
1705: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1706: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1707: (
1708: l_api_name,
1709: G_PKG_NAME,

Line 1706: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 1710: 'OKC_API.G_RET_STS_ERROR',

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

Line 1715: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 1716: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

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

Line 1720: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1716: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1717: (
1718: l_api_name,
1719: G_PKG_NAME,
1720: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1721: x_msg_count,
1722: x_msg_data,
1723: '_PVT'
1724: );

Line 1726: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1722: x_msg_data,
1723: '_PVT'
1724: );
1725: WHEN OTHERS THEN
1726: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1727: (
1728: l_api_name,
1729: G_PKG_NAME,
1730: 'OTHERS',

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

1745: p_cprv_rec IN cprv_rec_type) IS
1746:
1747: l_api_version CONSTANT NUMBER := 1;
1748: l_api_name CONSTANT VARCHAR2(30) := 'V_delete_row';
1749: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1750: l_cprv_rec cprv_rec_type := p_cprv_rec;
1751: l_cpr_rec cpr_rec_type;
1752: BEGIN
1753: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1749: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1750: l_cprv_rec cprv_rec_type := p_cprv_rec;
1751: l_cpr_rec cpr_rec_type;
1752: BEGIN
1753: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1754: G_PKG_NAME,
1755: p_init_msg_list,
1756: l_api_version,
1757: p_api_version,

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

1756: l_api_version,
1757: p_api_version,
1758: '_PVT',
1759: x_return_status);
1760: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1761: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1762: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1763: RAISE OKC_API.G_EXCEPTION_ERROR;
1764: END IF;

Line 1761: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1757: p_api_version,
1758: '_PVT',
1759: x_return_status);
1760: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1761: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1762: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1763: RAISE OKC_API.G_EXCEPTION_ERROR;
1764: END IF;
1765: --------------------------------------

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

1758: '_PVT',
1759: x_return_status);
1760: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1761: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1762: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1763: RAISE OKC_API.G_EXCEPTION_ERROR;
1764: END IF;
1765: --------------------------------------
1766: -- Move VIEW record to "Child" records

Line 1763: RAISE OKC_API.G_EXCEPTION_ERROR;

1759: x_return_status);
1760: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1761: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1762: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1763: RAISE OKC_API.G_EXCEPTION_ERROR;
1764: END IF;
1765: --------------------------------------
1766: -- Move VIEW record to "Child" records
1767: --------------------------------------

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

1775: x_msg_count,
1776: x_msg_data,
1777: l_cpr_rec
1778: );
1779: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1780: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1781: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1782: RAISE OKC_API.G_EXCEPTION_ERROR;
1783: END IF;

Line 1780: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1776: x_msg_data,
1777: l_cpr_rec
1778: );
1779: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1780: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1781: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1782: RAISE OKC_API.G_EXCEPTION_ERROR;
1783: END IF;
1784: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1777: l_cpr_rec
1778: );
1779: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1780: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1781: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1782: RAISE OKC_API.G_EXCEPTION_ERROR;
1783: END IF;
1784: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1785: EXCEPTION

Line 1782: RAISE OKC_API.G_EXCEPTION_ERROR;

1778: );
1779: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1780: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1781: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1782: RAISE OKC_API.G_EXCEPTION_ERROR;
1783: END IF;
1784: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1785: EXCEPTION
1786: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1780: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1781: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1782: RAISE OKC_API.G_EXCEPTION_ERROR;
1783: END IF;
1784: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1785: EXCEPTION
1786: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1787: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1788: (

Line 1786: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1782: RAISE OKC_API.G_EXCEPTION_ERROR;
1783: END IF;
1784: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1785: EXCEPTION
1786: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1787: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1788: (
1789: l_api_name,
1790: G_PKG_NAME,

Line 1787: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1783: END IF;
1784: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1785: EXCEPTION
1786: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1787: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1788: (
1789: l_api_name,
1790: G_PKG_NAME,
1791: 'OKC_API.G_RET_STS_ERROR',

Line 1791: 'OKC_API.G_RET_STS_ERROR',

1787: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1788: (
1789: l_api_name,
1790: G_PKG_NAME,
1791: 'OKC_API.G_RET_STS_ERROR',
1792: x_msg_count,
1793: x_msg_data,
1794: '_PVT'
1795: );

Line 1796: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1792: x_msg_count,
1793: x_msg_data,
1794: '_PVT'
1795: );
1796: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1797: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1798: (
1799: l_api_name,
1800: G_PKG_NAME,

Line 1797: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1793: x_msg_data,
1794: '_PVT'
1795: );
1796: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1797: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1798: (
1799: l_api_name,
1800: G_PKG_NAME,
1801: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1801: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1797: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1798: (
1799: l_api_name,
1800: G_PKG_NAME,
1801: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1802: x_msg_count,
1803: x_msg_data,
1804: '_PVT'
1805: );

Line 1807: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1803: x_msg_data,
1804: '_PVT'
1805: );
1806: WHEN OTHERS THEN
1807: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1808: (
1809: l_api_name,
1810: G_PKG_NAME,
1811: 'OTHERS',

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

1826: p_cprv_tbl IN cprv_tbl_type) IS
1827:
1828: l_api_version CONSTANT NUMBER := 1;
1829: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
1830: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1831: i NUMBER := 0;
1832: BEGIN
1833: OKC_API.init_msg_list(p_init_msg_list);
1834: -- Make sure PL/SQL table has records in it before passing

Line 1833: OKC_API.init_msg_list(p_init_msg_list);

1829: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
1830: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1831: i NUMBER := 0;
1832: BEGIN
1833: OKC_API.init_msg_list(p_init_msg_list);
1834: -- Make sure PL/SQL table has records in it before passing
1835: IF (p_cprv_tbl.COUNT > 0) THEN
1836: i := p_cprv_tbl.FIRST;
1837: LOOP

Line 1840: p_init_msg_list => OKC_API.G_FALSE,

1836: i := p_cprv_tbl.FIRST;
1837: LOOP
1838: delete_row (
1839: p_api_version => p_api_version,
1840: p_init_msg_list => OKC_API.G_FALSE,
1841: x_return_status => x_return_status,
1842: x_msg_count => x_msg_count,
1843: x_msg_data => x_msg_data,
1844: p_cprv_rec => p_cprv_tbl(i));

Line 1850: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1846: i := p_cprv_tbl.NEXT(i);
1847: END LOOP;
1848: END IF;
1849: EXCEPTION
1850: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1851: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1852: (
1853: l_api_name,
1854: G_PKG_NAME,

Line 1851: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1847: END LOOP;
1848: END IF;
1849: EXCEPTION
1850: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1851: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1852: (
1853: l_api_name,
1854: G_PKG_NAME,
1855: 'OKC_API.G_RET_STS_ERROR',

Line 1855: 'OKC_API.G_RET_STS_ERROR',

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

Line 1860: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1856: x_msg_count,
1857: x_msg_data,
1858: '_PVT'
1859: );
1860: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1861: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1862: (
1863: l_api_name,
1864: G_PKG_NAME,

Line 1861: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1857: x_msg_data,
1858: '_PVT'
1859: );
1860: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1861: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1862: (
1863: l_api_name,
1864: G_PKG_NAME,
1865: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1865: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1861: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1862: (
1863: l_api_name,
1864: G_PKG_NAME,
1865: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1866: x_msg_count,
1867: x_msg_data,
1868: '_PVT'
1869: );

Line 1871: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1867: x_msg_data,
1868: '_PVT'
1869: );
1870: WHEN OTHERS THEN
1871: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1872: (
1873: l_api_name,
1874: G_PKG_NAME,
1875: 'OTHERS',