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.OKL_SERVICE_INTEGRATION_PUB dependencies on OKC_API

Line 44: x_return_status := OKC_API.START_ACTIVITY(

40:
41:
42: -- call START_ACTIVITY to create savepoint, check compatibility
43: -- and initialize message list
44: x_return_status := OKC_API.START_ACTIVITY(
45: p_api_name => l_api_name,
46: p_pkg_name => G_PKG_NAME,
47: p_init_msg_list => p_init_msg_list,
48: l_api_version => l_api_version,

Line 54: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

50: p_api_type => G_API_TYPE,
51: x_return_status => x_return_status);
52:
53: -- check if activity started successfully
54: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
55: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
56: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
57: raise OKC_API.G_EXCEPTION_ERROR;
58: END IF;

Line 55: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

51: x_return_status => x_return_status);
52:
53: -- check if activity started successfully
54: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
55: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
56: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
57: raise OKC_API.G_EXCEPTION_ERROR;
58: END IF;
59:

Line 56: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

52:
53: -- check if activity started successfully
54: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
55: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
56: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
57: raise OKC_API.G_EXCEPTION_ERROR;
58: END IF;
59:
60: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 57: raise OKC_API.G_EXCEPTION_ERROR;

53: -- check if activity started successfully
54: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
55: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
56: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
57: raise OKC_API.G_EXCEPTION_ERROR;
58: END IF;
59:
60: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
61: okl_service_integration_pvt.create_link_service_line(

Line 74: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

70: p_supplier_id => p_supplier_id,
71: x_okl_service_line_id => x_okl_service_line_id
72: );
73:
74: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
75: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
76: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
77: raise OKC_API.G_EXCEPTION_ERROR;
78: END IF;

Line 75: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

71: x_okl_service_line_id => x_okl_service_line_id
72: );
73:
74: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
75: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
76: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
77: raise OKC_API.G_EXCEPTION_ERROR;
78: END IF;
79:

Line 76: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

72: );
73:
74: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
75: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
76: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
77: raise OKC_API.G_EXCEPTION_ERROR;
78: END IF;
79:
80: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 77: raise OKC_API.G_EXCEPTION_ERROR;

73:
74: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
75: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
76: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
77: raise OKC_API.G_EXCEPTION_ERROR;
78: END IF;
79:
80: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
81:

Line 87: when OKC_API.G_EXCEPTION_ERROR then

83: x_msg_data => x_msg_data);
84:
85: EXCEPTION
86:
87: when OKC_API.G_EXCEPTION_ERROR then
88: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
89: p_api_name => l_api_name,
90: p_pkg_name => G_PKG_NAME,
91: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 88: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

84:
85: EXCEPTION
86:
87: when OKC_API.G_EXCEPTION_ERROR then
88: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
89: p_api_name => l_api_name,
90: p_pkg_name => G_PKG_NAME,
91: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
92: x_msg_count => x_msg_count,

Line 91: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

87: when OKC_API.G_EXCEPTION_ERROR then
88: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
89: p_api_name => l_api_name,
90: p_pkg_name => G_PKG_NAME,
91: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
92: x_msg_count => x_msg_count,
93: x_msg_data => x_msg_data,
94: p_api_type => G_API_TYPE);
95:

Line 96: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

92: x_msg_count => x_msg_count,
93: x_msg_data => x_msg_data,
94: p_api_type => G_API_TYPE);
95:
96: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
97: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
98: p_api_name => l_api_name,
99: p_pkg_name => G_PKG_NAME,
100: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 97: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

93: x_msg_data => x_msg_data,
94: p_api_type => G_API_TYPE);
95:
96: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
97: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
98: p_api_name => l_api_name,
99: p_pkg_name => G_PKG_NAME,
100: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
101: x_msg_count => x_msg_count,

Line 100: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

96: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
97: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
98: p_api_name => l_api_name,
99: p_pkg_name => G_PKG_NAME,
100: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
101: x_msg_count => x_msg_count,
102: x_msg_data => x_msg_data,
103: p_api_type => G_API_TYPE);
104:

Line 106: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

102: x_msg_data => x_msg_data,
103: p_api_type => G_API_TYPE);
104:
105: when OTHERS then
106: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
107: p_api_name => l_api_name,
108: p_pkg_name => G_PKG_NAME,
109: p_exc_name => 'OTHERS',
110: x_msg_count => x_msg_count,

Line 145: x_return_status := OKC_API.START_ACTIVITY(

141: BEGIN -- main process begins here
142:
143: -- call START_ACTIVITY to create savepoint, check compatibility
144: -- and initialize message list
145: x_return_status := OKC_API.START_ACTIVITY(
146: p_api_name => l_api_name,
147: p_pkg_name => G_PKG_NAME,
148: p_init_msg_list => p_init_msg_list,
149: l_api_version => l_api_version,

Line 155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

151: p_api_type => G_API_TYPE,
152: x_return_status => x_return_status);
153:
154: -- check if activity started successfully
155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
158: raise OKC_API.G_EXCEPTION_ERROR;
159: END IF;

Line 156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

152: x_return_status => x_return_status);
153:
154: -- check if activity started successfully
155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
158: raise OKC_API.G_EXCEPTION_ERROR;
159: END IF;
160:

Line 157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

153:
154: -- check if activity started successfully
155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
158: raise OKC_API.G_EXCEPTION_ERROR;
159: END IF;
160:
161: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 158: raise OKC_API.G_EXCEPTION_ERROR;

154: -- check if activity started successfully
155: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
156: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
157: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
158: raise OKC_API.G_EXCEPTION_ERROR;
159: END IF;
160:
161: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
162:

Line 176: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

172: p_supplier_id => p_supplier_id,
173: x_okl_service_line_id => x_okl_service_line_id
174: );
175:
176: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
177: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
178: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
179: raise OKC_API.G_EXCEPTION_ERROR;
180: END IF;

Line 177: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

173: x_okl_service_line_id => x_okl_service_line_id
174: );
175:
176: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
177: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
178: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
179: raise OKC_API.G_EXCEPTION_ERROR;
180: END IF;
181:

Line 178: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

174: );
175:
176: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
177: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
178: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
179: raise OKC_API.G_EXCEPTION_ERROR;
180: END IF;
181:
182: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 179: raise OKC_API.G_EXCEPTION_ERROR;

175:
176: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
177: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
178: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
179: raise OKC_API.G_EXCEPTION_ERROR;
180: END IF;
181:
182: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
183:

Line 189: when OKC_API.G_EXCEPTION_ERROR then

185: x_msg_data => x_msg_data);
186:
187: EXCEPTION
188:
189: when OKC_API.G_EXCEPTION_ERROR then
190: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
191: p_api_name => l_api_name,
192: p_pkg_name => G_PKG_NAME,
193: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 190: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

186:
187: EXCEPTION
188:
189: when OKC_API.G_EXCEPTION_ERROR then
190: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
191: p_api_name => l_api_name,
192: p_pkg_name => G_PKG_NAME,
193: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
194: x_msg_count => x_msg_count,

Line 193: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

189: when OKC_API.G_EXCEPTION_ERROR then
190: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
191: p_api_name => l_api_name,
192: p_pkg_name => G_PKG_NAME,
193: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
194: x_msg_count => x_msg_count,
195: x_msg_data => x_msg_data,
196: p_api_type => G_API_TYPE);
197:

Line 198: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

194: x_msg_count => x_msg_count,
195: x_msg_data => x_msg_data,
196: p_api_type => G_API_TYPE);
197:
198: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
199: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
200: p_api_name => l_api_name,
201: p_pkg_name => G_PKG_NAME,
202: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 199: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

195: x_msg_data => x_msg_data,
196: p_api_type => G_API_TYPE);
197:
198: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
199: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
200: p_api_name => l_api_name,
201: p_pkg_name => G_PKG_NAME,
202: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
203: x_msg_count => x_msg_count,

Line 202: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

198: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
199: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
200: p_api_name => l_api_name,
201: p_pkg_name => G_PKG_NAME,
202: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
203: x_msg_count => x_msg_count,
204: x_msg_data => x_msg_data,
205: p_api_type => G_API_TYPE);
206:

Line 208: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

204: x_msg_data => x_msg_data,
205: p_api_type => G_API_TYPE);
206:
207: when OTHERS then
208: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
209: p_api_name => l_api_name,
210: p_pkg_name => G_PKG_NAME,
211: p_exc_name => 'OTHERS',
212: x_msg_count => x_msg_count,

Line 248: x_return_status := OKC_API.START_ACTIVITY(

244: BEGIN
245:
246: -- call START_ACTIVITY to create savepoint, check compatibility
247: -- and initialize message list
248: x_return_status := OKC_API.START_ACTIVITY(
249: p_api_name => l_api_name,
250: p_pkg_name => G_PKG_NAME,
251: p_init_msg_list => p_init_msg_list,
252: l_api_version => l_api_version,

Line 258: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

254: p_api_type => G_API_TYPE,
255: x_return_status => x_return_status);
256:
257: -- check if activity started successfully
258: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
259: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
260: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
261: raise OKC_API.G_EXCEPTION_ERROR;
262: END IF;

Line 259: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

255: x_return_status => x_return_status);
256:
257: -- check if activity started successfully
258: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
259: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
260: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
261: raise OKC_API.G_EXCEPTION_ERROR;
262: END IF;
263:

Line 260: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

256:
257: -- check if activity started successfully
258: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
259: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
260: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
261: raise OKC_API.G_EXCEPTION_ERROR;
262: END IF;
263:
264: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 261: raise OKC_API.G_EXCEPTION_ERROR;

257: -- check if activity started successfully
258: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
259: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
260: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
261: raise OKC_API.G_EXCEPTION_ERROR;
262: END IF;
263:
264: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
265:

Line 278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

274: p_okl_service_line_id => p_okl_service_line_id,
275: p_oks_service_line_id => p_oks_service_line_id
276: );
277:
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;

Line 279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

275: p_oks_service_line_id => p_oks_service_line_id
276: );
277:
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283:

Line 280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

276: );
277:
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283:
284: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 281: raise OKC_API.G_EXCEPTION_ERROR;

277:
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283:
284: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
285:

Line 290: when OKC_API.G_EXCEPTION_ERROR then

286: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
287: x_msg_data => x_msg_data);
288:
289: EXCEPTION
290: when OKC_API.G_EXCEPTION_ERROR then
291: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
292: p_api_name => l_api_name,
293: p_pkg_name => G_PKG_NAME,
294: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 291: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

287: x_msg_data => x_msg_data);
288:
289: EXCEPTION
290: when OKC_API.G_EXCEPTION_ERROR then
291: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
292: p_api_name => l_api_name,
293: p_pkg_name => G_PKG_NAME,
294: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
295: x_msg_count => x_msg_count,

Line 294: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

290: when OKC_API.G_EXCEPTION_ERROR then
291: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
292: p_api_name => l_api_name,
293: p_pkg_name => G_PKG_NAME,
294: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
295: x_msg_count => x_msg_count,
296: x_msg_data => x_msg_data,
297: p_api_type => G_API_TYPE);
298:

Line 299: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

295: x_msg_count => x_msg_count,
296: x_msg_data => x_msg_data,
297: p_api_type => G_API_TYPE);
298:
299: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
300: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
301: p_api_name => l_api_name,
302: p_pkg_name => G_PKG_NAME,
303: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 300: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

296: x_msg_data => x_msg_data,
297: p_api_type => G_API_TYPE);
298:
299: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
300: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
301: p_api_name => l_api_name,
302: p_pkg_name => G_PKG_NAME,
303: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
304: x_msg_count => x_msg_count,

Line 303: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

299: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
300: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
301: p_api_name => l_api_name,
302: p_pkg_name => G_PKG_NAME,
303: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
304: x_msg_count => x_msg_count,
305: x_msg_data => x_msg_data,
306: p_api_type => G_API_TYPE);
307:

Line 309: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

305: x_msg_data => x_msg_data,
306: p_api_type => G_API_TYPE);
307:
308: when OTHERS then
309: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
310: p_api_name => l_api_name,
311: p_pkg_name => G_PKG_NAME,
312: p_exc_name => 'OTHERS',
313: x_msg_count => x_msg_count,

Line 343: x_return_status := OKC_API.G_RET_STS_SUCCESS;

339: l_api_version CONSTANT NUMBER := 1;
340:
341: BEGIN -- main process begins here
342:
343: x_return_status := OKC_API.G_RET_STS_SUCCESS;
344: -- call START_ACTIVITY to create savepoint, check compatibility
345: -- and initialize message list
346: x_return_status := OKC_API.START_ACTIVITY(
347: p_api_name => l_api_name,

Line 346: x_return_status := OKC_API.START_ACTIVITY(

342:
343: x_return_status := OKC_API.G_RET_STS_SUCCESS;
344: -- call START_ACTIVITY to create savepoint, check compatibility
345: -- and initialize message list
346: x_return_status := OKC_API.START_ACTIVITY(
347: p_api_name => l_api_name,
348: p_pkg_name => G_PKG_NAME,
349: p_init_msg_list => p_init_msg_list,
350: l_api_version => l_api_version,

Line 356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

352: p_api_type => G_API_TYPE,
353: x_return_status => x_return_status);
354:
355: -- check if activity started successfully
356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
359: raise OKC_API.G_EXCEPTION_ERROR;
360: END IF;

Line 357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

353: x_return_status => x_return_status);
354:
355: -- check if activity started successfully
356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
359: raise OKC_API.G_EXCEPTION_ERROR;
360: END IF;
361:

Line 358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

354:
355: -- check if activity started successfully
356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
359: raise OKC_API.G_EXCEPTION_ERROR;
360: END IF;
361:
362: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 359: raise OKC_API.G_EXCEPTION_ERROR;

355: -- check if activity started successfully
356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
359: raise OKC_API.G_EXCEPTION_ERROR;
360: END IF;
361:
362: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
363:

Line 374: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

370: p_clev_rec => p_clev_rec,
371: p_klev_rec => p_klev_rec
372: );
373:
374: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;

Line 375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

371: p_klev_rec => p_klev_rec
372: );
373:
374: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;
379:

Line 376: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

372: );
373:
374: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;
379:
380: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 377: raise OKC_API.G_EXCEPTION_ERROR;

373:
374: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;
379:
380: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
381:

Line 386: when OKC_API.G_EXCEPTION_ERROR then

382: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
383: x_msg_data => x_msg_data);
384:
385: EXCEPTION
386: when OKC_API.G_EXCEPTION_ERROR then
387: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
388: p_api_name => l_api_name,
389: p_pkg_name => G_PKG_NAME,
390: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 387: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

383: x_msg_data => x_msg_data);
384:
385: EXCEPTION
386: when OKC_API.G_EXCEPTION_ERROR then
387: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
388: p_api_name => l_api_name,
389: p_pkg_name => G_PKG_NAME,
390: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
391: x_msg_count => x_msg_count,

Line 390: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

386: when OKC_API.G_EXCEPTION_ERROR then
387: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
388: p_api_name => l_api_name,
389: p_pkg_name => G_PKG_NAME,
390: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
391: x_msg_count => x_msg_count,
392: x_msg_data => x_msg_data,
393: p_api_type => G_API_TYPE);
394:

Line 395: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

391: x_msg_count => x_msg_count,
392: x_msg_data => x_msg_data,
393: p_api_type => G_API_TYPE);
394:
395: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
396: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
397: p_api_name => l_api_name,
398: p_pkg_name => G_PKG_NAME,
399: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 396: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

392: x_msg_data => x_msg_data,
393: p_api_type => G_API_TYPE);
394:
395: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
396: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
397: p_api_name => l_api_name,
398: p_pkg_name => G_PKG_NAME,
399: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
400: x_msg_count => x_msg_count,

Line 399: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

395: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
396: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
397: p_api_name => l_api_name,
398: p_pkg_name => G_PKG_NAME,
399: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
400: x_msg_count => x_msg_count,
401: x_msg_data => x_msg_data,
402: p_api_type => G_API_TYPE);
403:

Line 405: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

401: x_msg_data => x_msg_data,
402: p_api_type => G_API_TYPE);
403:
404: when OTHERS then
405: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
406: p_api_name => l_api_name,
407: p_pkg_name => G_PKG_NAME,
408: p_exc_name => 'OTHERS',
409: x_msg_count => x_msg_count,

Line 445: x_return_status := OKC_API.G_RET_STS_SUCCESS;

441: l_api_version CONSTANT NUMBER := 1;
442:
443: BEGIN -- main process begins here
444:
445: x_return_status := OKC_API.G_RET_STS_SUCCESS;
446: -- call START_ACTIVITY to create savepoint, check compatibility
447: -- and initialize message list
448: x_return_status := OKC_API.START_ACTIVITY(
449: p_api_name => l_api_name,

Line 448: x_return_status := OKC_API.START_ACTIVITY(

444:
445: x_return_status := OKC_API.G_RET_STS_SUCCESS;
446: -- call START_ACTIVITY to create savepoint, check compatibility
447: -- and initialize message list
448: x_return_status := OKC_API.START_ACTIVITY(
449: p_api_name => l_api_name,
450: p_pkg_name => G_PKG_NAME,
451: p_init_msg_list => p_init_msg_list,
452: l_api_version => l_api_version,

Line 458: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

454: p_api_type => G_API_TYPE,
455: x_return_status => x_return_status);
456:
457: -- check if activity started successfully
458: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
459: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
460: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
461: raise OKC_API.G_EXCEPTION_ERROR;
462: END IF;

Line 459: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

455: x_return_status => x_return_status);
456:
457: -- check if activity started successfully
458: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
459: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
460: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
461: raise OKC_API.G_EXCEPTION_ERROR;
462: END IF;
463:

Line 460: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

456:
457: -- check if activity started successfully
458: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
459: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
460: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
461: raise OKC_API.G_EXCEPTION_ERROR;
462: END IF;
463:
464: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 461: raise OKC_API.G_EXCEPTION_ERROR;

457: -- check if activity started successfully
458: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
459: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
460: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
461: raise OKC_API.G_EXCEPTION_ERROR;
462: END IF;
463:
464: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
465:

Line 481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

477: p_klev_rec => p_klev_rec,
478: x_okl_service_line_id => x_okl_service_line_id
479: );
480:
481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
482: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
484: raise OKC_API.G_EXCEPTION_ERROR;
485: END IF;

Line 482: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

478: x_okl_service_line_id => x_okl_service_line_id
479: );
480:
481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
482: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
484: raise OKC_API.G_EXCEPTION_ERROR;
485: END IF;
486:

Line 483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

479: );
480:
481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
482: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
484: raise OKC_API.G_EXCEPTION_ERROR;
485: END IF;
486:
487: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 484: raise OKC_API.G_EXCEPTION_ERROR;

480:
481: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
482: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
483: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
484: raise OKC_API.G_EXCEPTION_ERROR;
485: END IF;
486:
487: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
488:

Line 493: when OKC_API.G_EXCEPTION_ERROR then

489: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
490: x_msg_data => x_msg_data);
491:
492: EXCEPTION
493: when OKC_API.G_EXCEPTION_ERROR then
494: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
495: p_api_name => l_api_name,
496: p_pkg_name => G_PKG_NAME,
497: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 494: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

490: x_msg_data => x_msg_data);
491:
492: EXCEPTION
493: when OKC_API.G_EXCEPTION_ERROR then
494: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
495: p_api_name => l_api_name,
496: p_pkg_name => G_PKG_NAME,
497: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
498: x_msg_count => x_msg_count,

Line 497: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

493: when OKC_API.G_EXCEPTION_ERROR then
494: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
495: p_api_name => l_api_name,
496: p_pkg_name => G_PKG_NAME,
497: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
498: x_msg_count => x_msg_count,
499: x_msg_data => x_msg_data,
500: p_api_type => G_API_TYPE);
501:

Line 502: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

498: x_msg_count => x_msg_count,
499: x_msg_data => x_msg_data,
500: p_api_type => G_API_TYPE);
501:
502: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
503: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
504: p_api_name => l_api_name,
505: p_pkg_name => G_PKG_NAME,
506: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 503: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

499: x_msg_data => x_msg_data,
500: p_api_type => G_API_TYPE);
501:
502: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
503: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
504: p_api_name => l_api_name,
505: p_pkg_name => G_PKG_NAME,
506: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
507: x_msg_count => x_msg_count,

Line 506: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

502: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
503: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
504: p_api_name => l_api_name,
505: p_pkg_name => G_PKG_NAME,
506: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
507: x_msg_count => x_msg_count,
508: x_msg_data => x_msg_data,
509: p_api_type => G_API_TYPE);
510:

Line 512: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

508: x_msg_data => x_msg_data,
509: p_api_type => G_API_TYPE);
510:
511: when OTHERS then
512: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
513: p_api_name => l_api_name,
514: p_pkg_name => G_PKG_NAME,
515: p_exc_name => 'OTHERS',
516: x_msg_count => x_msg_count,

Line 552: x_return_status := OKC_API.START_ACTIVITY(

548: BEGIN
549:
550: -- call START_ACTIVITY to create savepoint, check compatibility
551: -- and initialize message list
552: x_return_status := OKC_API.START_ACTIVITY(
553: p_api_name => l_api_name,
554: p_pkg_name => G_PKG_NAME,
555: p_init_msg_list => p_init_msg_list,
556: l_api_version => l_api_version,

Line 562: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

558: p_api_type => G_API_TYPE,
559: x_return_status => x_return_status);
560:
561: -- check if activity started successfully
562: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
563: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
564: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
565: raise OKC_API.G_EXCEPTION_ERROR;
566: END IF;

Line 563: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

559: x_return_status => x_return_status);
560:
561: -- check if activity started successfully
562: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
563: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
564: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
565: raise OKC_API.G_EXCEPTION_ERROR;
566: END IF;
567:

Line 564: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

560:
561: -- check if activity started successfully
562: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
563: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
564: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
565: raise OKC_API.G_EXCEPTION_ERROR;
566: END IF;
567:
568: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 565: raise OKC_API.G_EXCEPTION_ERROR;

561: -- check if activity started successfully
562: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
563: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
564: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
565: raise OKC_API.G_EXCEPTION_ERROR;
566: END IF;
567:
568: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
569: okl_service_integration_pvt.check_service_link(

Line 579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

575: p_lease_contract_id => p_lease_contract_id,
576: x_service_contract_id => x_service_contract_id
577: );
578:
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;

Line 580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

576: x_service_contract_id => x_service_contract_id
577: );
578:
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;
584:

Line 581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

577: );
578:
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;
584:
585: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 582: raise OKC_API.G_EXCEPTION_ERROR;

578:
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;
584:
585: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
586:

Line 591: when OKC_API.G_EXCEPTION_ERROR then

587: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
588: x_msg_data => x_msg_data);
589:
590: EXCEPTION
591: when OKC_API.G_EXCEPTION_ERROR then
592: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
593: p_api_name => l_api_name,
594: p_pkg_name => G_PKG_NAME,
595: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 592: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

588: x_msg_data => x_msg_data);
589:
590: EXCEPTION
591: when OKC_API.G_EXCEPTION_ERROR then
592: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
593: p_api_name => l_api_name,
594: p_pkg_name => G_PKG_NAME,
595: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
596: x_msg_count => x_msg_count,

Line 595: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

591: when OKC_API.G_EXCEPTION_ERROR then
592: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
593: p_api_name => l_api_name,
594: p_pkg_name => G_PKG_NAME,
595: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
596: x_msg_count => x_msg_count,
597: x_msg_data => x_msg_data,
598: p_api_type => G_API_TYPE);
599:

Line 600: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

596: x_msg_count => x_msg_count,
597: x_msg_data => x_msg_data,
598: p_api_type => G_API_TYPE);
599:
600: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
601: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
602: p_api_name => l_api_name,
603: p_pkg_name => G_PKG_NAME,
604: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 601: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

597: x_msg_data => x_msg_data,
598: p_api_type => G_API_TYPE);
599:
600: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
601: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
602: p_api_name => l_api_name,
603: p_pkg_name => G_PKG_NAME,
604: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
605: x_msg_count => x_msg_count,

Line 604: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

600: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
601: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
602: p_api_name => l_api_name,
603: p_pkg_name => G_PKG_NAME,
604: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
605: x_msg_count => x_msg_count,
606: x_msg_data => x_msg_data,
607: p_api_type => G_API_TYPE);
608:

Line 610: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

606: x_msg_data => x_msg_data,
607: p_api_type => G_API_TYPE);
608:
609: when OTHERS then
610: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
611: p_api_name => l_api_name,
612: p_pkg_name => G_PKG_NAME,
613: p_exc_name => 'OTHERS',
614: x_msg_count => x_msg_count,

Line 648: x_return_status := OKC_API.START_ACTIVITY(

644: BEGIN
645:
646: -- call START_ACTIVITY to create savepoint, check compatibility
647: -- and initialize message list
648: x_return_status := OKC_API.START_ACTIVITY(
649: p_api_name => l_api_name,
650: p_pkg_name => G_PKG_NAME,
651: p_init_msg_list => p_init_msg_list,
652: l_api_version => l_api_version,

Line 658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

654: p_api_type => G_API_TYPE,
655: x_return_status => x_return_status);
656:
657: -- check if activity started successfully
658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
659: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
660: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
661: raise OKC_API.G_EXCEPTION_ERROR;
662: END IF;

Line 659: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

655: x_return_status => x_return_status);
656:
657: -- check if activity started successfully
658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
659: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
660: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
661: raise OKC_API.G_EXCEPTION_ERROR;
662: END IF;
663:

Line 660: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

656:
657: -- check if activity started successfully
658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
659: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
660: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
661: raise OKC_API.G_EXCEPTION_ERROR;
662: END IF;
663:
664: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 661: raise OKC_API.G_EXCEPTION_ERROR;

657: -- check if activity started successfully
658: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
659: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
660: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
661: raise OKC_API.G_EXCEPTION_ERROR;
662: END IF;
663:
664: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
665: okl_service_integration_pvt.get_service_link_line(

Line 676: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

672: x_link_line_tbl => x_link_line_tbl,
673: x_service_contract_id => x_service_contract_id
674: );
675:
676: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
677: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
678: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
679: raise OKC_API.G_EXCEPTION_ERROR;
680: END IF;

Line 677: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

673: x_service_contract_id => x_service_contract_id
674: );
675:
676: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
677: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
678: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
679: raise OKC_API.G_EXCEPTION_ERROR;
680: END IF;
681:

Line 678: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

674: );
675:
676: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
677: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
678: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
679: raise OKC_API.G_EXCEPTION_ERROR;
680: END IF;
681:
682: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Line 679: raise OKC_API.G_EXCEPTION_ERROR;

675:
676: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
677: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
678: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
679: raise OKC_API.G_EXCEPTION_ERROR;
680: END IF;
681:
682: --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
683:

Line 688: when OKC_API.G_EXCEPTION_ERROR then

684: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
685: x_msg_data => x_msg_data);
686:
687: EXCEPTION
688: when OKC_API.G_EXCEPTION_ERROR then
689: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
690: p_api_name => l_api_name,
691: p_pkg_name => G_PKG_NAME,
692: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 689: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

685: x_msg_data => x_msg_data);
686:
687: EXCEPTION
688: when OKC_API.G_EXCEPTION_ERROR then
689: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
690: p_api_name => l_api_name,
691: p_pkg_name => G_PKG_NAME,
692: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
693: x_msg_count => x_msg_count,

Line 692: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

688: when OKC_API.G_EXCEPTION_ERROR then
689: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
690: p_api_name => l_api_name,
691: p_pkg_name => G_PKG_NAME,
692: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
693: x_msg_count => x_msg_count,
694: x_msg_data => x_msg_data,
695: p_api_type => G_API_TYPE);
696:

Line 697: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

693: x_msg_count => x_msg_count,
694: x_msg_data => x_msg_data,
695: p_api_type => G_API_TYPE);
696:
697: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
698: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
699: p_api_name => l_api_name,
700: p_pkg_name => G_PKG_NAME,
701: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 698: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

694: x_msg_data => x_msg_data,
695: p_api_type => G_API_TYPE);
696:
697: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
698: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
699: p_api_name => l_api_name,
700: p_pkg_name => G_PKG_NAME,
701: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
702: x_msg_count => x_msg_count,

Line 701: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

697: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
698: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
699: p_api_name => l_api_name,
700: p_pkg_name => G_PKG_NAME,
701: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
702: x_msg_count => x_msg_count,
703: x_msg_data => x_msg_data,
704: p_api_type => G_API_TYPE);
705:

Line 707: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

703: x_msg_data => x_msg_data,
704: p_api_type => G_API_TYPE);
705:
706: when OTHERS then
707: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
708: p_api_name => l_api_name,
709: p_pkg_name => G_PKG_NAME,
710: p_exc_name => 'OTHERS',
711: x_msg_count => x_msg_count,

Line 729: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

725: -- Called By:
726: ------------------------------------------------------------------------------
727: PROCEDURE create_cov_asset_line(
728: p_api_version IN NUMBER,
729: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
730: x_return_status OUT NOCOPY VARCHAR2,
731: x_msg_count OUT NOCOPY NUMBER,
732: x_msg_data OUT NOCOPY VARCHAR2,
733: p_clev_tbl IN clev_tbl_type,

Line 748: x_return_status := OKC_API.G_RET_STS_SUCCESS;

744:
745:
746: BEGIN -- main process begins here
747:
748: x_return_status := OKC_API.G_RET_STS_SUCCESS;
749: -- call START_ACTIVITY to create savepoint, check compatibility
750: -- and initialize message list
751: x_return_status := OKC_API.START_ACTIVITY(
752: p_api_name => l_api_name,

Line 751: x_return_status := OKC_API.START_ACTIVITY(

747:
748: x_return_status := OKC_API.G_RET_STS_SUCCESS;
749: -- call START_ACTIVITY to create savepoint, check compatibility
750: -- and initialize message list
751: x_return_status := OKC_API.START_ACTIVITY(
752: p_api_name => l_api_name,
753: p_pkg_name => G_PKG_NAME,
754: p_init_msg_list => p_init_msg_list,
755: l_api_version => l_api_version,

Line 761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

757: p_api_type => G_API_TYPE,
758: x_return_status => x_return_status);
759:
760: -- check if activity started successfully
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;

Line 762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

758: x_return_status => x_return_status);
759:
760: -- check if activity started successfully
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766:

Line 763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

759:
760: -- check if activity started successfully
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766:
767: OKL_SERVICE_INTEGRATION_PVT.CREATE_COV_ASSET_LINE (

Line 764: raise OKC_API.G_EXCEPTION_ERROR;

760: -- check if activity started successfully
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766:
767: OKL_SERVICE_INTEGRATION_PVT.CREATE_COV_ASSET_LINE (
768: p_api_version => p_api_version,

Line 782: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

778: x_klev_tbl => x_klev_tbl,
779: x_cimv_tbl => x_cimv_tbl
780: );
781:
782: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
783: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
784: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
785: raise OKC_API.G_EXCEPTION_ERROR;
786: END IF;

Line 783: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

779: x_cimv_tbl => x_cimv_tbl
780: );
781:
782: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
783: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
784: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
785: raise OKC_API.G_EXCEPTION_ERROR;
786: END IF;
787:

Line 784: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

780: );
781:
782: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
783: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
784: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
785: raise OKC_API.G_EXCEPTION_ERROR;
786: END IF;
787:
788: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,

Line 785: raise OKC_API.G_EXCEPTION_ERROR;

781:
782: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
783: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
784: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
785: raise OKC_API.G_EXCEPTION_ERROR;
786: END IF;
787:
788: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
789: x_msg_data => x_msg_data);

Line 792: when OKC_API.G_EXCEPTION_ERROR then

788: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
789: x_msg_data => x_msg_data);
790:
791: EXCEPTION
792: when OKC_API.G_EXCEPTION_ERROR then
793: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
794: p_api_name => l_api_name,
795: p_pkg_name => G_PKG_NAME,
796: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 793: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

789: x_msg_data => x_msg_data);
790:
791: EXCEPTION
792: when OKC_API.G_EXCEPTION_ERROR then
793: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
794: p_api_name => l_api_name,
795: p_pkg_name => G_PKG_NAME,
796: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
797: x_msg_count => x_msg_count,

Line 796: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

792: when OKC_API.G_EXCEPTION_ERROR then
793: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
794: p_api_name => l_api_name,
795: p_pkg_name => G_PKG_NAME,
796: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
797: x_msg_count => x_msg_count,
798: x_msg_data => x_msg_data,
799: p_api_type => G_API_TYPE);
800:

Line 801: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

797: x_msg_count => x_msg_count,
798: x_msg_data => x_msg_data,
799: p_api_type => G_API_TYPE);
800:
801: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
802: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
803: p_api_name => l_api_name,
804: p_pkg_name => G_PKG_NAME,
805: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 802: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

798: x_msg_data => x_msg_data,
799: p_api_type => G_API_TYPE);
800:
801: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
802: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
803: p_api_name => l_api_name,
804: p_pkg_name => G_PKG_NAME,
805: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
806: x_msg_count => x_msg_count,

Line 805: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

801: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
802: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
803: p_api_name => l_api_name,
804: p_pkg_name => G_PKG_NAME,
805: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
806: x_msg_count => x_msg_count,
807: x_msg_data => x_msg_data,
808: p_api_type => G_API_TYPE);
809:

Line 811: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

807: x_msg_data => x_msg_data,
808: p_api_type => G_API_TYPE);
809:
810: when OTHERS then
811: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
812: p_api_name => l_api_name,
813: p_pkg_name => G_PKG_NAME,
814: p_exc_name => 'OTHERS',
815: x_msg_count => x_msg_count,

Line 832: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

828: -- Called By:
829: ------------------------------------------------------------------------------
830: PROCEDURE update_cov_asset_line(
831: p_api_version IN NUMBER,
832: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
833: x_return_status OUT NOCOPY VARCHAR2,
834: x_msg_count OUT NOCOPY NUMBER,
835: x_msg_data OUT NOCOPY VARCHAR2,
836: p_clev_tbl IN clev_tbl_type,

Line 851: x_return_status := OKC_API.G_RET_STS_SUCCESS;

847:
848:
849: BEGIN -- main process begins here
850:
851: x_return_status := OKC_API.G_RET_STS_SUCCESS;
852: -- call START_ACTIVITY to create savepoint, check compatibility
853: -- and initialize message list
854: x_return_status := OKC_API.START_ACTIVITY(
855: p_api_name => l_api_name,

Line 854: x_return_status := OKC_API.START_ACTIVITY(

850:
851: x_return_status := OKC_API.G_RET_STS_SUCCESS;
852: -- call START_ACTIVITY to create savepoint, check compatibility
853: -- and initialize message list
854: x_return_status := OKC_API.START_ACTIVITY(
855: p_api_name => l_api_name,
856: p_pkg_name => G_PKG_NAME,
857: p_init_msg_list => p_init_msg_list,
858: l_api_version => l_api_version,

Line 864: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

860: p_api_type => G_API_TYPE,
861: x_return_status => x_return_status);
862:
863: -- check if activity started successfully
864: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
865: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
866: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
867: raise OKC_API.G_EXCEPTION_ERROR;
868: END IF;

Line 865: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

861: x_return_status => x_return_status);
862:
863: -- check if activity started successfully
864: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
865: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
866: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
867: raise OKC_API.G_EXCEPTION_ERROR;
868: END IF;
869:

Line 866: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

862:
863: -- check if activity started successfully
864: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
865: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
866: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
867: raise OKC_API.G_EXCEPTION_ERROR;
868: END IF;
869:
870: OKL_SERVICE_INTEGRATION_PVT.UPDATE_COV_ASSET_LINE (

Line 867: raise OKC_API.G_EXCEPTION_ERROR;

863: -- check if activity started successfully
864: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
865: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
866: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
867: raise OKC_API.G_EXCEPTION_ERROR;
868: END IF;
869:
870: OKL_SERVICE_INTEGRATION_PVT.UPDATE_COV_ASSET_LINE (
871: p_api_version => p_api_version,

Line 885: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

881: x_klev_tbl => x_klev_tbl,
882: x_cimv_tbl => x_cimv_tbl
883: );
884:
885: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
886: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
887: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
888: raise OKC_API.G_EXCEPTION_ERROR;
889: END IF;

Line 886: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

882: x_cimv_tbl => x_cimv_tbl
883: );
884:
885: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
886: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
887: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
888: raise OKC_API.G_EXCEPTION_ERROR;
889: END IF;
890:

Line 887: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

883: );
884:
885: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
886: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
887: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
888: raise OKC_API.G_EXCEPTION_ERROR;
889: END IF;
890:
891: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,

Line 888: raise OKC_API.G_EXCEPTION_ERROR;

884:
885: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
886: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
887: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
888: raise OKC_API.G_EXCEPTION_ERROR;
889: END IF;
890:
891: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
892: x_msg_data => x_msg_data);

Line 895: when OKC_API.G_EXCEPTION_ERROR then

891: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
892: x_msg_data => x_msg_data);
893:
894: EXCEPTION
895: when OKC_API.G_EXCEPTION_ERROR then
896: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
897: p_api_name => l_api_name,
898: p_pkg_name => G_PKG_NAME,
899: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 896: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

892: x_msg_data => x_msg_data);
893:
894: EXCEPTION
895: when OKC_API.G_EXCEPTION_ERROR then
896: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
897: p_api_name => l_api_name,
898: p_pkg_name => G_PKG_NAME,
899: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
900: x_msg_count => x_msg_count,

Line 899: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

895: when OKC_API.G_EXCEPTION_ERROR then
896: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
897: p_api_name => l_api_name,
898: p_pkg_name => G_PKG_NAME,
899: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
900: x_msg_count => x_msg_count,
901: x_msg_data => x_msg_data,
902: p_api_type => G_API_TYPE);
903:

Line 904: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

900: x_msg_count => x_msg_count,
901: x_msg_data => x_msg_data,
902: p_api_type => G_API_TYPE);
903:
904: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
905: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
906: p_api_name => l_api_name,
907: p_pkg_name => G_PKG_NAME,
908: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 905: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

901: x_msg_data => x_msg_data,
902: p_api_type => G_API_TYPE);
903:
904: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
905: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
906: p_api_name => l_api_name,
907: p_pkg_name => G_PKG_NAME,
908: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
909: x_msg_count => x_msg_count,

Line 908: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

904: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
905: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
906: p_api_name => l_api_name,
907: p_pkg_name => G_PKG_NAME,
908: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
909: x_msg_count => x_msg_count,
910: x_msg_data => x_msg_data,
911: p_api_type => G_API_TYPE);
912:

Line 914: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

910: x_msg_data => x_msg_data,
911: p_api_type => G_API_TYPE);
912:
913: when OTHERS then
914: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
915: p_api_name => l_api_name,
916: p_pkg_name => G_PKG_NAME,
917: p_exc_name => 'OTHERS',
918: x_msg_count => x_msg_count,

Line 936: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,

932: -- Called By:
933: ------------------------------------------------------------------------------
934: PROCEDURE initiate_service_booking(
935: p_api_version IN NUMBER,
936: p_init_msg_list IN VARCHAR2 DEFAULT OKC_API.G_FALSE,
937: x_return_status OUT NOCOPY VARCHAR2,
938: x_msg_count OUT NOCOPY NUMBER,
939: x_msg_data OUT NOCOPY VARCHAR2,
940: p_okl_chr_id IN OKC_K_HEADERS_B.ID%TYPE

Line 948: x_return_status := OKC_API.G_RET_STS_SUCCESS;

944: l_api_version CONSTANT NUMBER := 1;
945:
946: BEGIN
947:
948: x_return_status := OKC_API.G_RET_STS_SUCCESS;
949:
950: -- call START_ACTIVITY to create savepoint, check compatibility
951: -- and initialize message list
952: x_return_status := OKC_API.START_ACTIVITY(

Line 952: x_return_status := OKC_API.START_ACTIVITY(

948: x_return_status := OKC_API.G_RET_STS_SUCCESS;
949:
950: -- call START_ACTIVITY to create savepoint, check compatibility
951: -- and initialize message list
952: x_return_status := OKC_API.START_ACTIVITY(
953: p_api_name => l_api_name,
954: p_pkg_name => G_PKG_NAME,
955: p_init_msg_list => p_init_msg_list,
956: l_api_version => l_api_version,

Line 962: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

958: p_api_type => G_API_TYPE,
959: x_return_status => x_return_status);
960:
961: -- check if activity started successfully
962: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
963: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
964: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
965: raise OKC_API.G_EXCEPTION_ERROR;
966: END IF;

Line 963: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

959: x_return_status => x_return_status);
960:
961: -- check if activity started successfully
962: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
963: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
964: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
965: raise OKC_API.G_EXCEPTION_ERROR;
966: END IF;
967: --************************************************

Line 964: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

960:
961: -- check if activity started successfully
962: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
963: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
964: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
965: raise OKC_API.G_EXCEPTION_ERROR;
966: END IF;
967: --************************************************
968:

Line 965: raise OKC_API.G_EXCEPTION_ERROR;

961: -- check if activity started successfully
962: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
963: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
964: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
965: raise OKC_API.G_EXCEPTION_ERROR;
966: END IF;
967: --************************************************
968:
969: okl_service_integration_pvt.initiate_service_booking(

Line 978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then

974: x_msg_data => x_msg_data,
975: p_okl_chr_id => p_okl_chr_id
976: );
977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;

Line 979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

975: p_okl_chr_id => p_okl_chr_id
976: );
977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:

Line 980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then

976: );
977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:
984: --************************************************

Line 981: raise OKC_API.G_EXCEPTION_ERROR;

977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) then
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) then
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:
984: --************************************************
985:

Line 990: when OKC_API.G_EXCEPTION_ERROR then

986: OKL_API.END_ACTIVITY(x_msg_count => x_msg_count,
987: x_msg_data => x_msg_data);
988:
989: EXCEPTION
990: when OKC_API.G_EXCEPTION_ERROR then
991: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
992: p_api_name => l_api_name,
993: p_pkg_name => G_PKG_NAME,
994: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

Line 991: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

987: x_msg_data => x_msg_data);
988:
989: EXCEPTION
990: when OKC_API.G_EXCEPTION_ERROR then
991: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
992: p_api_name => l_api_name,
993: p_pkg_name => G_PKG_NAME,
994: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
995: x_msg_count => x_msg_count,

Line 994: p_exc_name => 'OKC_API.G_RET_STS_ERROR',

990: when OKC_API.G_EXCEPTION_ERROR then
991: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
992: p_api_name => l_api_name,
993: p_pkg_name => G_PKG_NAME,
994: p_exc_name => 'OKC_API.G_RET_STS_ERROR',
995: x_msg_count => x_msg_count,
996: x_msg_data => x_msg_data,
997: p_api_type => G_API_TYPE);
998:

Line 999: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then

995: x_msg_count => x_msg_count,
996: x_msg_data => x_msg_data,
997: p_api_type => G_API_TYPE);
998:
999: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1000: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1001: p_api_name => l_api_name,
1002: p_pkg_name => G_PKG_NAME,
1003: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1000: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

996: x_msg_data => x_msg_data,
997: p_api_type => G_API_TYPE);
998:
999: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1000: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1001: p_api_name => l_api_name,
1002: p_pkg_name => G_PKG_NAME,
1003: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1004: x_msg_count => x_msg_count,

Line 1003: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',

999: when OKC_API.G_EXCEPTION_UNEXPECTED_ERROR then
1000: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1001: p_api_name => l_api_name,
1002: p_pkg_name => G_PKG_NAME,
1003: p_exc_name => 'OKC_API.G_RET_STS_UNEXP_ERROR',
1004: x_msg_count => x_msg_count,
1005: x_msg_data => x_msg_data,
1006: p_api_type => G_API_TYPE);
1007:

Line 1009: x_return_status := OKC_API.HANDLE_EXCEPTIONS(

1005: x_msg_data => x_msg_data,
1006: p_api_type => G_API_TYPE);
1007:
1008: when OTHERS then
1009: x_return_status := OKC_API.HANDLE_EXCEPTIONS(
1010: p_api_name => l_api_name,
1011: p_pkg_name => G_PKG_NAME,
1012: p_exc_name => 'OTHERS',
1013: x_msg_count => x_msg_count,