APPS.OKC_PROCESS_PUB dependencies on OKC_API

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

97:
98: l_api_name CONSTANT VARCHAR2(30) := 'create_process_def';
99: l_return_status VARCHAR2(1);
100: BEGIN
101: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
102: p_init_msg_list,
103: '_PUB',
104: x_return_status);
105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

101: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
102: p_init_msg_list,
103: '_PUB',
104: x_return_status);
105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
108: raise OKC_API.G_EXCEPTION_ERROR;
109: END IF;

Line 106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

102: p_init_msg_list,
103: '_PUB',
104: x_return_status);
105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
108: raise OKC_API.G_EXCEPTION_ERROR;
109: END IF;
110:

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

103: '_PUB',
104: x_return_status);
105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
108: raise OKC_API.G_EXCEPTION_ERROR;
109: END IF;
110:
111: -- Call to Complex API procedure

Line 108: raise OKC_API.G_EXCEPTION_ERROR;

104: x_return_status);
105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
108: raise OKC_API.G_EXCEPTION_ERROR;
109: END IF;
110:
111: -- Call to Complex API procedure
112: okc_process_pvt.create_process_def(

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

118: p_pdfv_rec,
119: p_pdpv_tbl,
120: x_pdfv_rec,
121: x_pdpv_tbl);
122: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
123: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
124: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
125: raise OKC_API.G_EXCEPTION_ERROR;
126: END IF;

Line 123: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

119: p_pdpv_tbl,
120: x_pdfv_rec,
121: x_pdpv_tbl);
122: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
123: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
124: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
125: raise OKC_API.G_EXCEPTION_ERROR;
126: END IF;
127:

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

120: x_pdfv_rec,
121: x_pdpv_tbl);
122: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
123: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
124: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
125: raise OKC_API.G_EXCEPTION_ERROR;
126: END IF;
127:
128: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 125: raise OKC_API.G_EXCEPTION_ERROR;

121: x_pdpv_tbl);
122: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
123: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
124: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
125: raise OKC_API.G_EXCEPTION_ERROR;
126: END IF;
127:
128: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
129: EXCEPTION

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

124: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
125: raise OKC_API.G_EXCEPTION_ERROR;
126: END IF;
127:
128: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
129: EXCEPTION
130: WHEN OKC_API.G_EXCEPTION_ERROR THEN
131: x_return_status := OKC_API.HANDLE_EXCEPTIONS
132: (l_api_name,

Line 130: WHEN OKC_API.G_EXCEPTION_ERROR THEN

126: END IF;
127:
128: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
129: EXCEPTION
130: WHEN OKC_API.G_EXCEPTION_ERROR THEN
131: x_return_status := OKC_API.HANDLE_EXCEPTIONS
132: (l_api_name,
133: G_PKG_NAME,
134: 'OKC_API.G_RET_STS_ERROR',

Line 131: x_return_status := OKC_API.HANDLE_EXCEPTIONS

127:
128: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
129: EXCEPTION
130: WHEN OKC_API.G_EXCEPTION_ERROR THEN
131: x_return_status := OKC_API.HANDLE_EXCEPTIONS
132: (l_api_name,
133: G_PKG_NAME,
134: 'OKC_API.G_RET_STS_ERROR',
135: x_msg_count,

Line 134: 'OKC_API.G_RET_STS_ERROR',

130: WHEN OKC_API.G_EXCEPTION_ERROR THEN
131: x_return_status := OKC_API.HANDLE_EXCEPTIONS
132: (l_api_name,
133: G_PKG_NAME,
134: 'OKC_API.G_RET_STS_ERROR',
135: x_msg_count,
136: x_msg_data,
137: '_PUB');
138: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 138: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

134: 'OKC_API.G_RET_STS_ERROR',
135: x_msg_count,
136: x_msg_data,
137: '_PUB');
138: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
139: x_return_status := OKC_API.HANDLE_EXCEPTIONS
140: (l_api_name,
141: G_PKG_NAME,
142: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 139: x_return_status := OKC_API.HANDLE_EXCEPTIONS

135: x_msg_count,
136: x_msg_data,
137: '_PUB');
138: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
139: x_return_status := OKC_API.HANDLE_EXCEPTIONS
140: (l_api_name,
141: G_PKG_NAME,
142: 'OKC_API.G_RET_STS_UNEXP_ERROR',
143: x_msg_count,

Line 142: 'OKC_API.G_RET_STS_UNEXP_ERROR',

138: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
139: x_return_status := OKC_API.HANDLE_EXCEPTIONS
140: (l_api_name,
141: G_PKG_NAME,
142: 'OKC_API.G_RET_STS_UNEXP_ERROR',
143: x_msg_count,
144: x_msg_data,
145: '_PUB');
146: WHEN OTHERS THEN

Line 147: x_return_status := OKC_API.HANDLE_EXCEPTIONS

143: x_msg_count,
144: x_msg_data,
145: '_PUB');
146: WHEN OTHERS THEN
147: x_return_status := OKC_API.HANDLE_EXCEPTIONS
148: (l_api_name,
149: G_PKG_NAME,
150: 'OTHERS',
151: x_msg_count,

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

166: x_pdpv_tbl OUT NOCOPY pdpv_tbl_type) IS
167:
168: l_api_version CONSTANT NUMBER := 1;
169: l_api_name CONSTANT VARCHAR2(30) := 'V_update_process_def';
170: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
171:
172: BEGIN
173: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
174: p_init_msg_list,

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

169: l_api_name CONSTANT VARCHAR2(30) := 'V_update_process_def';
170: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
171:
172: BEGIN
173: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
174: p_init_msg_list,
175: '_PUB',
176: x_return_status);
177: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

173: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
174: p_init_msg_list,
175: '_PUB',
176: x_return_status);
177: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
179: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
180: raise OKC_API.G_EXCEPTION_ERROR;
181: END IF;

Line 178: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

174: p_init_msg_list,
175: '_PUB',
176: x_return_status);
177: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
179: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
180: raise OKC_API.G_EXCEPTION_ERROR;
181: END IF;
182:

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

175: '_PUB',
176: x_return_status);
177: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
179: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
180: raise OKC_API.G_EXCEPTION_ERROR;
181: END IF;
182:
183: --Call to Complex API procedure

Line 180: raise OKC_API.G_EXCEPTION_ERROR;

176: x_return_status);
177: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
178: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
179: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
180: raise OKC_API.G_EXCEPTION_ERROR;
181: END IF;
182:
183: --Call to Complex API procedure
184: okc_process_pvt.update_process_def(

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

190: p_pdfv_rec,
191: p_pdpv_tbl,
192: x_pdfv_rec,
193: x_pdpv_tbl);
194: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
195: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
196: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
197: raise OKC_API.G_EXCEPTION_ERROR;
198: END IF;

Line 195: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

191: p_pdpv_tbl,
192: x_pdfv_rec,
193: x_pdpv_tbl);
194: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
195: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
196: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
197: raise OKC_API.G_EXCEPTION_ERROR;
198: END IF;
199:

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

192: x_pdfv_rec,
193: x_pdpv_tbl);
194: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
195: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
196: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
197: raise OKC_API.G_EXCEPTION_ERROR;
198: END IF;
199:
200: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 197: raise OKC_API.G_EXCEPTION_ERROR;

193: x_pdpv_tbl);
194: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
195: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
196: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
197: raise OKC_API.G_EXCEPTION_ERROR;
198: END IF;
199:
200: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
201: EXCEPTION

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

196: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
197: raise OKC_API.G_EXCEPTION_ERROR;
198: END IF;
199:
200: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
201: EXCEPTION
202: WHEN OKC_API.G_EXCEPTION_ERROR THEN
203: x_return_status := OKC_API.HANDLE_EXCEPTIONS
204: (l_api_name,

Line 202: WHEN OKC_API.G_EXCEPTION_ERROR THEN

198: END IF;
199:
200: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
201: EXCEPTION
202: WHEN OKC_API.G_EXCEPTION_ERROR THEN
203: x_return_status := OKC_API.HANDLE_EXCEPTIONS
204: (l_api_name,
205: G_PKG_NAME,
206: 'OKC_API.G_RET_STS_ERROR',

Line 203: x_return_status := OKC_API.HANDLE_EXCEPTIONS

199:
200: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
201: EXCEPTION
202: WHEN OKC_API.G_EXCEPTION_ERROR THEN
203: x_return_status := OKC_API.HANDLE_EXCEPTIONS
204: (l_api_name,
205: G_PKG_NAME,
206: 'OKC_API.G_RET_STS_ERROR',
207: x_msg_count,

Line 206: 'OKC_API.G_RET_STS_ERROR',

202: WHEN OKC_API.G_EXCEPTION_ERROR THEN
203: x_return_status := OKC_API.HANDLE_EXCEPTIONS
204: (l_api_name,
205: G_PKG_NAME,
206: 'OKC_API.G_RET_STS_ERROR',
207: x_msg_count,
208: x_msg_data,
209: '_PUB');
210: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 210: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

206: 'OKC_API.G_RET_STS_ERROR',
207: x_msg_count,
208: x_msg_data,
209: '_PUB');
210: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
211: x_return_status := OKC_API.HANDLE_EXCEPTIONS
212: (l_api_name,
213: G_PKG_NAME,
214: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 211: x_return_status := OKC_API.HANDLE_EXCEPTIONS

207: x_msg_count,
208: x_msg_data,
209: '_PUB');
210: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
211: x_return_status := OKC_API.HANDLE_EXCEPTIONS
212: (l_api_name,
213: G_PKG_NAME,
214: 'OKC_API.G_RET_STS_UNEXP_ERROR',
215: x_msg_count,

Line 214: 'OKC_API.G_RET_STS_UNEXP_ERROR',

210: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
211: x_return_status := OKC_API.HANDLE_EXCEPTIONS
212: (l_api_name,
213: G_PKG_NAME,
214: 'OKC_API.G_RET_STS_UNEXP_ERROR',
215: x_msg_count,
216: x_msg_data,
217: '_PUB');
218: WHEN OTHERS THEN

Line 219: x_return_status := OKC_API.HANDLE_EXCEPTIONS

215: x_msg_count,
216: x_msg_data,
217: '_PUB');
218: WHEN OTHERS THEN
219: x_return_status := OKC_API.HANDLE_EXCEPTIONS
220: (l_api_name,
221: G_PKG_NAME,
222: 'OTHERS',
223: x_msg_count,

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

236: p_pdpv_tbl IN pdpv_tbl_type) IS
237:
238: l_api_version CONSTANT NUMBER := 1;
239: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_process_def';
240: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
241:
242: BEGIN
243: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
244: p_init_msg_list,

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

239: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_process_def';
240: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
241:
242: BEGIN
243: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
244: p_init_msg_list,
245: '_PUB',
246: x_return_status);
247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

243: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
244: p_init_msg_list,
245: '_PUB',
246: x_return_status);
247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
248: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
250: raise OKC_API.G_EXCEPTION_ERROR;
251: END IF;

Line 248: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

244: p_init_msg_list,
245: '_PUB',
246: x_return_status);
247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
248: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
250: raise OKC_API.G_EXCEPTION_ERROR;
251: END IF;
252:

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

245: '_PUB',
246: x_return_status);
247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
248: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
250: raise OKC_API.G_EXCEPTION_ERROR;
251: END IF;
252:
253: okc_process_pvt.validate_process_def(

Line 250: raise OKC_API.G_EXCEPTION_ERROR;

246: x_return_status);
247: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
248: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
249: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
250: raise OKC_API.G_EXCEPTION_ERROR;
251: END IF;
252:
253: okc_process_pvt.validate_process_def(
254: p_api_version,

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

257: x_msg_count,
258: x_msg_data,
259: p_pdfv_rec,
260: p_pdpv_tbl);
261: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
262: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
263: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
264: raise OKC_API.G_EXCEPTION_ERROR;
265: END IF;

Line 262: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

258: x_msg_data,
259: p_pdfv_rec,
260: p_pdpv_tbl);
261: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
262: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
263: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
264: raise OKC_API.G_EXCEPTION_ERROR;
265: END IF;
266:

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

259: p_pdfv_rec,
260: p_pdpv_tbl);
261: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
262: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
263: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
264: raise OKC_API.G_EXCEPTION_ERROR;
265: END IF;
266:
267: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 264: raise OKC_API.G_EXCEPTION_ERROR;

260: p_pdpv_tbl);
261: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
262: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
263: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
264: raise OKC_API.G_EXCEPTION_ERROR;
265: END IF;
266:
267: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
268: EXCEPTION

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

263: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
264: raise OKC_API.G_EXCEPTION_ERROR;
265: END IF;
266:
267: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
268: EXCEPTION
269: WHEN OKC_API.G_EXCEPTION_ERROR THEN
270: x_return_status := OKC_API.HANDLE_EXCEPTIONS
271: (l_api_name,

Line 269: WHEN OKC_API.G_EXCEPTION_ERROR THEN

265: END IF;
266:
267: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
268: EXCEPTION
269: WHEN OKC_API.G_EXCEPTION_ERROR THEN
270: x_return_status := OKC_API.HANDLE_EXCEPTIONS
271: (l_api_name,
272: G_PKG_NAME,
273: 'OKC_API.G_RET_STS_ERROR',

Line 270: x_return_status := OKC_API.HANDLE_EXCEPTIONS

266:
267: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
268: EXCEPTION
269: WHEN OKC_API.G_EXCEPTION_ERROR THEN
270: x_return_status := OKC_API.HANDLE_EXCEPTIONS
271: (l_api_name,
272: G_PKG_NAME,
273: 'OKC_API.G_RET_STS_ERROR',
274: x_msg_count,

Line 273: 'OKC_API.G_RET_STS_ERROR',

269: WHEN OKC_API.G_EXCEPTION_ERROR THEN
270: x_return_status := OKC_API.HANDLE_EXCEPTIONS
271: (l_api_name,
272: G_PKG_NAME,
273: 'OKC_API.G_RET_STS_ERROR',
274: x_msg_count,
275: x_msg_data,
276: '_PUB');
277: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 277: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

273: 'OKC_API.G_RET_STS_ERROR',
274: x_msg_count,
275: x_msg_data,
276: '_PUB');
277: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
278: x_return_status := OKC_API.HANDLE_EXCEPTIONS
279: (l_api_name,
280: G_PKG_NAME,
281: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 278: x_return_status := OKC_API.HANDLE_EXCEPTIONS

274: x_msg_count,
275: x_msg_data,
276: '_PUB');
277: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
278: x_return_status := OKC_API.HANDLE_EXCEPTIONS
279: (l_api_name,
280: G_PKG_NAME,
281: 'OKC_API.G_RET_STS_UNEXP_ERROR',
282: x_msg_count,

Line 281: 'OKC_API.G_RET_STS_UNEXP_ERROR',

277: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
278: x_return_status := OKC_API.HANDLE_EXCEPTIONS
279: (l_api_name,
280: G_PKG_NAME,
281: 'OKC_API.G_RET_STS_UNEXP_ERROR',
282: x_msg_count,
283: x_msg_data,
284: '_PUB');
285: WHEN OTHERS THEN

Line 286: x_return_status := OKC_API.HANDLE_EXCEPTIONS

282: x_msg_count,
283: x_msg_data,
284: '_PUB');
285: WHEN OTHERS THEN
286: x_return_status := OKC_API.HANDLE_EXCEPTIONS
287: (l_api_name,
288: G_PKG_NAME,
289: 'OTHERS',
290: x_msg_count,

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

303: x_pdfv_rec OUT NOCOPY pdfv_rec_type) IS
304:
305: l_api_name CONSTANT VARCHAR2(30) := 'create_proc_def';
306: l_api_version CONSTANT NUMBER := 1.0;
307: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
308: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
309: BEGIN
310: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
311: g_pkg_name,

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

306: l_api_version CONSTANT NUMBER := 1.0;
307: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
308: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
309: BEGIN
310: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
311: g_pkg_name,
312: p_init_msg_list,
313: l_api_version,
314: p_api_version,

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

314: p_api_version,
315: '_PUB',
316: x_return_status);
317:
318: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
319: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
320: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
321: RAISE OKC_API.G_EXCEPTION_ERROR;
322: END IF;

Line 319: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

315: '_PUB',
316: x_return_status);
317:
318: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
319: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
320: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
321: RAISE OKC_API.G_EXCEPTION_ERROR;
322: END IF;
323:

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

316: x_return_status);
317:
318: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
319: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
320: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
321: RAISE OKC_API.G_EXCEPTION_ERROR;
322: END IF;
323:
324: -- USER HOOK CALL FOR BEFORE, STARTS

Line 321: RAISE OKC_API.G_EXCEPTION_ERROR;

317:
318: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
319: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
320: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
321: RAISE OKC_API.G_EXCEPTION_ERROR;
322: END IF;
323:
324: -- USER HOOK CALL FOR BEFORE, STARTS
325: g_pdfv_rec := l_pdfv_rec;

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

327: okc_util.call_user_hook(x_return_status => x_return_status,
328: p_package_name => g_pkg_name,
329: p_procedure_name => l_api_name,
330: p_before_after => 'B');
331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
332: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
334: RAISE OKC_API.G_EXCEPTION_ERROR;
335: END IF;

Line 332: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

328: p_package_name => g_pkg_name,
329: p_procedure_name => l_api_name,
330: p_before_after => 'B');
331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
332: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
334: RAISE OKC_API.G_EXCEPTION_ERROR;
335: END IF;
336:

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

329: p_procedure_name => l_api_name,
330: p_before_after => 'B');
331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
332: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
334: RAISE OKC_API.G_EXCEPTION_ERROR;
335: END IF;
336:
337: --get values back from hook call

Line 334: RAISE OKC_API.G_EXCEPTION_ERROR;

330: p_before_after => 'B');
331: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
332: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
333: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
334: RAISE OKC_API.G_EXCEPTION_ERROR;
335: END IF;
336:
337: --get values back from hook call
338: l_pdfv_rec := migrate_pdfv(l_pdfv_rec, g_pdfv_rec);

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

344: x_msg_count => x_msg_count,
345: x_msg_data => x_msg_data,
346: p_pdfv_rec => l_pdfv_rec,
347: x_pdfv_rec => x_pdfv_rec);
348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
351: raise OKC_API.G_EXCEPTION_ERROR;
352: END IF;

Line 349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

345: x_msg_data => x_msg_data,
346: p_pdfv_rec => l_pdfv_rec,
347: x_pdfv_rec => x_pdfv_rec);
348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
351: raise OKC_API.G_EXCEPTION_ERROR;
352: END IF;
353:

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

346: p_pdfv_rec => l_pdfv_rec,
347: x_pdfv_rec => x_pdfv_rec);
348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
351: raise OKC_API.G_EXCEPTION_ERROR;
352: END IF;
353:
354: --USER HOOK CALL FOR AFTER, STARTS

Line 351: raise OKC_API.G_EXCEPTION_ERROR;

347: x_pdfv_rec => x_pdfv_rec);
348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
351: raise OKC_API.G_EXCEPTION_ERROR;
352: END IF;
353:
354: --USER HOOK CALL FOR AFTER, STARTS
355: g_pdfv_rec := x_pdfv_rec;

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

358: p_package_name => g_pkg_name,
359: p_procedure_name => l_api_name,
360: p_before_after => 'A');
361:
362: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
363: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
364: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
365: RAISE OKC_API.G_EXCEPTION_ERROR;
366: END IF;

Line 363: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

359: p_procedure_name => l_api_name,
360: p_before_after => 'A');
361:
362: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
363: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
364: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
365: RAISE OKC_API.G_EXCEPTION_ERROR;
366: END IF;
367: --USER HOOK CALL FOR AFTER, ENDS

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

360: p_before_after => 'A');
361:
362: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
363: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
364: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
365: RAISE OKC_API.G_EXCEPTION_ERROR;
366: END IF;
367: --USER HOOK CALL FOR AFTER, ENDS
368:

Line 365: RAISE OKC_API.G_EXCEPTION_ERROR;

361:
362: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
363: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
364: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
365: RAISE OKC_API.G_EXCEPTION_ERROR;
366: END IF;
367: --USER HOOK CALL FOR AFTER, ENDS
368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

365: RAISE OKC_API.G_EXCEPTION_ERROR;
366: END IF;
367: --USER HOOK CALL FOR AFTER, ENDS
368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
370:
371: EXCEPTION
372: WHEN OKC_API.G_EXCEPTION_ERROR THEN
373: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 372: WHEN OKC_API.G_EXCEPTION_ERROR THEN

368:
369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
370:
371: EXCEPTION
372: WHEN OKC_API.G_EXCEPTION_ERROR THEN
373: x_return_status := OKC_API.HANDLE_EXCEPTIONS
374: (
375: l_api_name,
376: G_PKG_NAME,

Line 373: x_return_status := OKC_API.HANDLE_EXCEPTIONS

369: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
370:
371: EXCEPTION
372: WHEN OKC_API.G_EXCEPTION_ERROR THEN
373: x_return_status := OKC_API.HANDLE_EXCEPTIONS
374: (
375: l_api_name,
376: G_PKG_NAME,
377: 'OKC_API.G_RET_STS_ERROR',

Line 377: 'OKC_API.G_RET_STS_ERROR',

373: x_return_status := OKC_API.HANDLE_EXCEPTIONS
374: (
375: l_api_name,
376: G_PKG_NAME,
377: 'OKC_API.G_RET_STS_ERROR',
378: x_msg_count,
379: x_msg_data,
380: '_PUB'
381: );

Line 383: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

379: x_msg_data,
380: '_PUB'
381: );
382:
383: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
384: x_return_status := OKC_API.HANDLE_EXCEPTIONS
385: (
386: l_api_name,
387: G_PKG_NAME,

Line 384: x_return_status := OKC_API.HANDLE_EXCEPTIONS

380: '_PUB'
381: );
382:
383: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
384: x_return_status := OKC_API.HANDLE_EXCEPTIONS
385: (
386: l_api_name,
387: G_PKG_NAME,
388: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 388: 'OKC_API.G_RET_STS_UNEXP_ERROR',

384: x_return_status := OKC_API.HANDLE_EXCEPTIONS
385: (
386: l_api_name,
387: G_PKG_NAME,
388: 'OKC_API.G_RET_STS_UNEXP_ERROR',
389: x_msg_count,
390: x_msg_data,
391: '_PUB'
392: );

Line 395: x_return_status := OKC_API.HANDLE_EXCEPTIONS

391: '_PUB'
392: );
393:
394: WHEN OTHERS THEN
395: x_return_status := OKC_API.HANDLE_EXCEPTIONS
396: (
397: l_api_name,
398: G_PKG_NAME,
399: 'OTHERS',

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

410: x_msg_data OUT NOCOPY VARCHAR2,
411: p_pdfv_tbl IN pdfv_tbl_type,
412: x_pdfv_tbl OUT NOCOPY pdfv_tbl_type) IS
413:
414: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
415: i NUMBER := 0;
416: BEGIN
417: --Initialize the return status
418: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 418: x_return_status := OKC_API.G_RET_STS_SUCCESS;

414: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
415: i NUMBER := 0;
416: BEGIN
417: --Initialize the return status
418: x_return_status := OKC_API.G_RET_STS_SUCCESS;
419:
420: IF p_pdfv_tbl.COUNT > 0 THEN
421: i := p_pdfv_tbl.FIRST;
422: LOOP

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

427: x_msg_count,
428: x_msg_data,
429: p_pdfv_tbl(i),
430: x_pdfv_tbl(i));
431: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
432: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
433: x_return_status := l_return_status;
434: raise G_EXCEPTION_HALT_VALIDATION;
435: ELSE

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

428: x_msg_data,
429: p_pdfv_tbl(i),
430: x_pdfv_tbl(i));
431: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
432: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
433: x_return_status := l_return_status;
434: raise G_EXCEPTION_HALT_VALIDATION;
435: ELSE
436: x_return_status := l_return_status;

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

444: WHEN G_EXCEPTION_HALT_VALIDATION THEN
445: NULL;
446:
447: WHEN OTHERS THEN
448: OKC_API.set_message(p_app_name => g_app_name,
449: p_msg_name => g_unexpected_error,
450: p_token1 => g_sqlcode_token,
451: p_token1_value => sqlcode,
452: p_token2 => g_sqlerrm_token,

Line 454: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

450: p_token1 => g_sqlcode_token,
451: p_token1_value => sqlcode,
452: p_token2 => g_sqlerrm_token,
453: p_token2_value => sqlerrm);
454: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
455: END create_proc_def;
456:
457: PROCEDURE lock_proc_def(p_api_version IN NUMBER,
458: p_init_msg_list IN VARCHAR2 ,

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

462: p_pdfv_rec IN pdfv_rec_type) IS
463:
464: l_api_name CONSTANT VARCHAR2(30) := 'lock_proc_def';
465: l_api_version CONSTANT NUMBER := 1.0;
466: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
467: BEGIN
468: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
469: g_pkg_name,
470: p_init_msg_list,

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

464: l_api_name CONSTANT VARCHAR2(30) := 'lock_proc_def';
465: l_api_version CONSTANT NUMBER := 1.0;
466: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
467: BEGIN
468: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
469: g_pkg_name,
470: p_init_msg_list,
471: l_api_version,
472: p_api_version,

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

472: p_api_version,
473: '_PUB',
474: x_return_status);
475:
476: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
478: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
479: RAISE OKC_API.G_EXCEPTION_ERROR;
480: END IF;

Line 477: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

473: '_PUB',
474: x_return_status);
475:
476: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
478: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
479: RAISE OKC_API.G_EXCEPTION_ERROR;
480: END IF;
481:

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

474: x_return_status);
475:
476: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
478: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
479: RAISE OKC_API.G_EXCEPTION_ERROR;
480: END IF;
481:
482: -- Call to procedure of complex API

Line 479: RAISE OKC_API.G_EXCEPTION_ERROR;

475:
476: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
477: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
478: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
479: RAISE OKC_API.G_EXCEPTION_ERROR;
480: END IF;
481:
482: -- Call to procedure of complex API
483: okc_process_pvt.lock_proc_def(p_api_version => p_api_version,

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

485: x_return_status => x_return_status,
486: x_msg_count => x_msg_count,
487: x_msg_data => x_msg_data,
488: p_pdfv_rec => p_pdfv_rec);
489: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
490: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
491: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
492: RAISE OKC_API.G_EXCEPTION_ERROR;
493: END IF;

Line 490: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

486: x_msg_count => x_msg_count,
487: x_msg_data => x_msg_data,
488: p_pdfv_rec => p_pdfv_rec);
489: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
490: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
491: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
492: RAISE OKC_API.G_EXCEPTION_ERROR;
493: END IF;
494:

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

487: x_msg_data => x_msg_data,
488: p_pdfv_rec => p_pdfv_rec);
489: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
490: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
491: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
492: RAISE OKC_API.G_EXCEPTION_ERROR;
493: END IF;
494:
495: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 492: RAISE OKC_API.G_EXCEPTION_ERROR;

488: p_pdfv_rec => p_pdfv_rec);
489: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
490: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
491: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
492: RAISE OKC_API.G_EXCEPTION_ERROR;
493: END IF;
494:
495: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
496:

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

491: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
492: RAISE OKC_API.G_EXCEPTION_ERROR;
493: END IF;
494:
495: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
496:
497: EXCEPTION
498: WHEN OKC_API.G_EXCEPTION_ERROR THEN
499: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 498: WHEN OKC_API.G_EXCEPTION_ERROR THEN

494:
495: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
496:
497: EXCEPTION
498: WHEN OKC_API.G_EXCEPTION_ERROR THEN
499: x_return_status := OKC_API.HANDLE_EXCEPTIONS
500: (
501: l_api_name,
502: G_PKG_NAME,

Line 499: x_return_status := OKC_API.HANDLE_EXCEPTIONS

495: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
496:
497: EXCEPTION
498: WHEN OKC_API.G_EXCEPTION_ERROR THEN
499: x_return_status := OKC_API.HANDLE_EXCEPTIONS
500: (
501: l_api_name,
502: G_PKG_NAME,
503: 'OKC_API.G_RET_STS_ERROR',

Line 503: 'OKC_API.G_RET_STS_ERROR',

499: x_return_status := OKC_API.HANDLE_EXCEPTIONS
500: (
501: l_api_name,
502: G_PKG_NAME,
503: 'OKC_API.G_RET_STS_ERROR',
504: x_msg_count,
505: x_msg_data,
506: '_PUB'
507: );

Line 509: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

505: x_msg_data,
506: '_PUB'
507: );
508:
509: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
510: x_return_status := OKC_API.HANDLE_EXCEPTIONS
511: (
512: l_api_name,
513: G_PKG_NAME,

Line 510: x_return_status := OKC_API.HANDLE_EXCEPTIONS

506: '_PUB'
507: );
508:
509: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
510: x_return_status := OKC_API.HANDLE_EXCEPTIONS
511: (
512: l_api_name,
513: G_PKG_NAME,
514: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 514: 'OKC_API.G_RET_STS_UNEXP_ERROR',

510: x_return_status := OKC_API.HANDLE_EXCEPTIONS
511: (
512: l_api_name,
513: G_PKG_NAME,
514: 'OKC_API.G_RET_STS_UNEXP_ERROR',
515: x_msg_count,
516: x_msg_data,
517: '_PUB'
518: );

Line 521: x_return_status := OKC_API.HANDLE_EXCEPTIONS

517: '_PUB'
518: );
519:
520: WHEN OTHERS THEN
521: x_return_status := OKC_API.HANDLE_EXCEPTIONS
522: (
523: l_api_name,
524: G_PKG_NAME,
525: 'OTHERS',

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

535: x_msg_count OUT NOCOPY NUMBER,
536: x_msg_data OUT NOCOPY VARCHAR2,
537: p_pdfv_tbl IN pdfv_tbl_type) IS
538:
539: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
540: i NUMBER := 0;
541: BEGIN
542: x_return_status := OKC_API.G_RET_STS_SUCCESS;
543: IF p_pdfv_tbl.COUNT > 0 THEN

Line 542: x_return_status := OKC_API.G_RET_STS_SUCCESS;

538:
539: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
540: i NUMBER := 0;
541: BEGIN
542: x_return_status := OKC_API.G_RET_STS_SUCCESS;
543: IF p_pdfv_tbl.COUNT > 0 THEN
544: i := p_pdfv_tbl.FIRST;
545: LOOP
546: lock_proc_def(

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

549: l_return_status,
550: x_msg_count,
551: x_msg_data,
552: p_pdfv_tbl(i));
553: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
554: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
555: x_return_status := l_return_status;
556: raise G_EXCEPTION_HALT_VALIDATION;
557: ELSE

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

550: x_msg_count,
551: x_msg_data,
552: p_pdfv_tbl(i));
553: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
554: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
555: x_return_status := l_return_status;
556: raise G_EXCEPTION_HALT_VALIDATION;
557: ELSE
558: x_return_status := l_return_status;

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

566: WHEN G_EXCEPTION_HALT_VALIDATION THEN
567: NULL;
568:
569: WHEN OTHERS THEN
570: OKC_API.set_message(p_app_name => g_app_name,
571: p_msg_name => g_unexpected_error,
572: p_token1 => g_sqlcode_token,
573: p_token1_value => sqlcode,
574: p_token2 => g_sqlerrm_token,

Line 576: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

572: p_token1 => g_sqlcode_token,
573: p_token1_value => sqlcode,
574: p_token2 => g_sqlerrm_token,
575: p_token2_value => sqlerrm);
576: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
577: END lock_proc_def;
578:
579: PROCEDURE update_proc_def(p_api_version IN NUMBER,
580: p_init_msg_list IN VARCHAR2 ,

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

585: x_pdfv_rec OUT NOCOPY pdfv_rec_type) IS
586:
587: l_api_name CONSTANT VARCHAR2(30) := 'update_proc_def';
588: l_api_version CONSTANT NUMBER := 1.0;
589: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
590: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
591: BEGIN
592: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
593: g_pkg_name,

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

588: l_api_version CONSTANT NUMBER := 1.0;
589: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
590: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
591: BEGIN
592: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
593: g_pkg_name,
594: p_init_msg_list,
595: l_api_version,
596: p_api_version,

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

596: p_api_version,
597: '_PUB',
598: x_return_status);
599:
600: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
601: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
602: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
603: RAISE OKC_API.G_EXCEPTION_ERROR;
604: END IF;

Line 601: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

597: '_PUB',
598: x_return_status);
599:
600: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
601: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
602: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
603: RAISE OKC_API.G_EXCEPTION_ERROR;
604: END IF;
605:

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

598: x_return_status);
599:
600: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
601: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
602: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
603: RAISE OKC_API.G_EXCEPTION_ERROR;
604: END IF;
605:
606: -- USER HOOK CALL FOR BEFORE, STARTS

Line 603: RAISE OKC_API.G_EXCEPTION_ERROR;

599:
600: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
601: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
602: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
603: RAISE OKC_API.G_EXCEPTION_ERROR;
604: END IF;
605:
606: -- USER HOOK CALL FOR BEFORE, STARTS
607: g_pdfv_rec := l_pdfv_rec;

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

610: p_package_name => g_pkg_name,
611: p_procedure_name => l_api_name,
612: p_before_after => 'B');
613:
614: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
616: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
617: RAISE OKC_API.G_EXCEPTION_ERROR;
618: END IF;

Line 615: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

611: p_procedure_name => l_api_name,
612: p_before_after => 'B');
613:
614: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
616: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
617: RAISE OKC_API.G_EXCEPTION_ERROR;
618: END IF;
619:

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

612: p_before_after => 'B');
613:
614: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
616: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
617: RAISE OKC_API.G_EXCEPTION_ERROR;
618: END IF;
619:
620: --get values back from hook call

Line 617: RAISE OKC_API.G_EXCEPTION_ERROR;

613:
614: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
615: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
616: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
617: RAISE OKC_API.G_EXCEPTION_ERROR;
618: END IF;
619:
620: --get values back from hook call
621: l_pdfv_rec := migrate_pdfv(l_pdfv_rec, g_pdfv_rec);

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

627: x_msg_count => x_msg_count,
628: x_msg_data => x_msg_data,
629: p_pdfv_rec => l_pdfv_rec,
630: x_pdfv_rec => x_pdfv_rec);
631: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;

Line 632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

628: x_msg_data => x_msg_data,
629: p_pdfv_rec => l_pdfv_rec,
630: x_pdfv_rec => x_pdfv_rec);
631: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;
636:

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

629: p_pdfv_rec => l_pdfv_rec,
630: x_pdfv_rec => x_pdfv_rec);
631: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;
636:
637: --USER HOOK CALL FOR AFTER, STARTS

Line 634: RAISE OKC_API.G_EXCEPTION_ERROR;

630: x_pdfv_rec => x_pdfv_rec);
631: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
632: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
633: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
634: RAISE OKC_API.G_EXCEPTION_ERROR;
635: END IF;
636:
637: --USER HOOK CALL FOR AFTER, STARTS
638: g_pdfv_rec := x_pdfv_rec;

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

641: p_package_name => g_pkg_name,
642: p_procedure_name => l_api_name,
643: p_before_after => 'A');
644:
645: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
646: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
647: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
648: RAISE OKC_API.G_EXCEPTION_ERROR;
649: END IF;

Line 646: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

642: p_procedure_name => l_api_name,
643: p_before_after => 'A');
644:
645: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
646: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
647: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
648: RAISE OKC_API.G_EXCEPTION_ERROR;
649: END IF;
650: --USER HOOK CALL FOR AFTER, ENDS

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

643: p_before_after => 'A');
644:
645: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
646: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
647: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
648: RAISE OKC_API.G_EXCEPTION_ERROR;
649: END IF;
650: --USER HOOK CALL FOR AFTER, ENDS
651:

Line 648: RAISE OKC_API.G_EXCEPTION_ERROR;

644:
645: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
646: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
647: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
648: RAISE OKC_API.G_EXCEPTION_ERROR;
649: END IF;
650: --USER HOOK CALL FOR AFTER, ENDS
651:
652: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

648: RAISE OKC_API.G_EXCEPTION_ERROR;
649: END IF;
650: --USER HOOK CALL FOR AFTER, ENDS
651:
652: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
653:
654: EXCEPTION
655: WHEN OKC_API.G_EXCEPTION_ERROR THEN
656: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 655: WHEN OKC_API.G_EXCEPTION_ERROR THEN

651:
652: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
653:
654: EXCEPTION
655: WHEN OKC_API.G_EXCEPTION_ERROR THEN
656: x_return_status := OKC_API.HANDLE_EXCEPTIONS
657: (
658: l_api_name,
659: G_PKG_NAME,

Line 656: x_return_status := OKC_API.HANDLE_EXCEPTIONS

652: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
653:
654: EXCEPTION
655: WHEN OKC_API.G_EXCEPTION_ERROR THEN
656: x_return_status := OKC_API.HANDLE_EXCEPTIONS
657: (
658: l_api_name,
659: G_PKG_NAME,
660: 'OKC_API.G_RET_STS_ERROR',

Line 660: 'OKC_API.G_RET_STS_ERROR',

656: x_return_status := OKC_API.HANDLE_EXCEPTIONS
657: (
658: l_api_name,
659: G_PKG_NAME,
660: 'OKC_API.G_RET_STS_ERROR',
661: x_msg_count,
662: x_msg_data,
663: '_PUB'
664: );

Line 666: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

662: x_msg_data,
663: '_PUB'
664: );
665:
666: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
667: x_return_status := OKC_API.HANDLE_EXCEPTIONS
668: (
669: l_api_name,
670: G_PKG_NAME,

Line 667: x_return_status := OKC_API.HANDLE_EXCEPTIONS

663: '_PUB'
664: );
665:
666: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
667: x_return_status := OKC_API.HANDLE_EXCEPTIONS
668: (
669: l_api_name,
670: G_PKG_NAME,
671: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 671: 'OKC_API.G_RET_STS_UNEXP_ERROR',

667: x_return_status := OKC_API.HANDLE_EXCEPTIONS
668: (
669: l_api_name,
670: G_PKG_NAME,
671: 'OKC_API.G_RET_STS_UNEXP_ERROR',
672: x_msg_count,
673: x_msg_data,
674: '_PUB'
675: );

Line 678: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

694: x_msg_data OUT NOCOPY VARCHAR2,
695: p_pdfv_tbl IN pdfv_tbl_type,
696: x_pdfv_tbl OUT NOCOPY pdfv_tbl_type) IS
697:
698: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
699: i NUMBER := 0;
700: BEGIN
701: x_return_status := OKC_API.G_RET_STS_SUCCESS;
702: IF p_pdfv_tbl.COUNT > 0 THEN

Line 701: x_return_status := OKC_API.G_RET_STS_SUCCESS;

697:
698: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
699: i NUMBER := 0;
700: BEGIN
701: x_return_status := OKC_API.G_RET_STS_SUCCESS;
702: IF p_pdfv_tbl.COUNT > 0 THEN
703: i := p_pdfv_tbl.FIRST;
704: LOOP
705: update_proc_def(

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

709: x_msg_count,
710: x_msg_data,
711: p_pdfv_tbl(i),
712: x_pdfv_tbl(i));
713: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
714: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
715: x_return_status := l_return_status;
716: raise G_EXCEPTION_HALT_VALIDATION;
717: ELSE

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

710: x_msg_data,
711: p_pdfv_tbl(i),
712: x_pdfv_tbl(i));
713: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
714: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
715: x_return_status := l_return_status;
716: raise G_EXCEPTION_HALT_VALIDATION;
717: ELSE
718: x_return_status := l_return_status;

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

726: WHEN G_EXCEPTION_HALT_VALIDATION THEN
727: NULL;
728:
729: WHEN OTHERS THEN
730: OKC_API.set_message(p_app_name => g_app_name,
731: p_msg_name => g_unexpected_error,
732: p_token1 => g_sqlcode_token,
733: p_token1_value => sqlcode,
734: p_token2 => g_sqlerrm_token,

Line 736: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

732: p_token1 => g_sqlcode_token,
733: p_token1_value => sqlcode,
734: p_token2 => g_sqlerrm_token,
735: p_token2_value => sqlerrm);
736: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
737: END update_proc_def;
738:
739: PROCEDURE delete_proc_def(p_api_version IN NUMBER,
740: p_init_msg_list IN VARCHAR2 ,

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

744: p_pdfv_rec IN pdfv_rec_type) IS
745:
746: l_api_name CONSTANT VARCHAR2(30) := 'delete_proc_def';
747: l_api_version CONSTANT NUMBER := 1.0;
748: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
749: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
750: BEGIN
751: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
752: g_pkg_name,

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

747: l_api_version CONSTANT NUMBER := 1.0;
748: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
749: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
750: BEGIN
751: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
752: g_pkg_name,
753: p_init_msg_list,
754: l_api_version,
755: p_api_version,

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

755: p_api_version,
756: '_PUB',
757: x_return_status);
758:
759: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
760: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
761: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
762: RAISE OKC_API.G_EXCEPTION_ERROR;
763: END IF;

Line 760: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

756: '_PUB',
757: x_return_status);
758:
759: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
760: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
761: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
762: RAISE OKC_API.G_EXCEPTION_ERROR;
763: END IF;
764:

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

757: x_return_status);
758:
759: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
760: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
761: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
762: RAISE OKC_API.G_EXCEPTION_ERROR;
763: END IF;
764:
765: -- USER HOOK CALL FOR BEFORE, STARTS

Line 762: RAISE OKC_API.G_EXCEPTION_ERROR;

758:
759: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
760: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
761: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
762: RAISE OKC_API.G_EXCEPTION_ERROR;
763: END IF;
764:
765: -- USER HOOK CALL FOR BEFORE, STARTS
766: g_pdfv_rec := l_pdfv_rec;

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

768: okc_util.call_user_hook(x_return_status => x_return_status,
769: p_package_name => g_pkg_name,
770: p_procedure_name => l_api_name,
771: p_before_after => 'B');
772: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
773: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
774: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
775: RAISE OKC_API.G_EXCEPTION_ERROR;
776: END IF;

Line 773: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

769: p_package_name => g_pkg_name,
770: p_procedure_name => l_api_name,
771: p_before_after => 'B');
772: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
773: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
774: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
775: RAISE OKC_API.G_EXCEPTION_ERROR;
776: END IF;
777:

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

770: p_procedure_name => l_api_name,
771: p_before_after => 'B');
772: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
773: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
774: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
775: RAISE OKC_API.G_EXCEPTION_ERROR;
776: END IF;
777:
778: --get values back from hook call

Line 775: RAISE OKC_API.G_EXCEPTION_ERROR;

771: p_before_after => 'B');
772: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
773: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
774: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
775: RAISE OKC_API.G_EXCEPTION_ERROR;
776: END IF;
777:
778: --get values back from hook call
779: l_pdfv_rec := migrate_pdfv(l_pdfv_rec, g_pdfv_rec);

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

784: x_return_status => x_return_status,
785: x_msg_count => x_msg_count,
786: x_msg_data => x_msg_data,
787: p_pdfv_rec => l_pdfv_rec);
788: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
789: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
790: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
791: RAISE OKC_API.G_EXCEPTION_ERROR;
792: END IF;

Line 789: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

785: x_msg_count => x_msg_count,
786: x_msg_data => x_msg_data,
787: p_pdfv_rec => l_pdfv_rec);
788: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
789: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
790: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
791: RAISE OKC_API.G_EXCEPTION_ERROR;
792: END IF;
793:

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

786: x_msg_data => x_msg_data,
787: p_pdfv_rec => l_pdfv_rec);
788: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
789: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
790: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
791: RAISE OKC_API.G_EXCEPTION_ERROR;
792: END IF;
793:
794: --USER HOOK CALL FOR AFTER, STARTS

Line 791: RAISE OKC_API.G_EXCEPTION_ERROR;

787: p_pdfv_rec => l_pdfv_rec);
788: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
789: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
790: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
791: RAISE OKC_API.G_EXCEPTION_ERROR;
792: END IF;
793:
794: --USER HOOK CALL FOR AFTER, STARTS
795: okc_util.call_user_hook(x_return_status => x_return_status,

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

796: p_package_name => g_pkg_name,
797: p_procedure_name => l_api_name,
798: p_before_after => 'A');
799:
800: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
801: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
802: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
803: RAISE OKC_API.G_EXCEPTION_ERROR;
804: END IF;

Line 801: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

797: p_procedure_name => l_api_name,
798: p_before_after => 'A');
799:
800: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
801: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
802: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
803: RAISE OKC_API.G_EXCEPTION_ERROR;
804: END IF;
805: --USER HOOK CALL FOR AFTER, ENDS

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

798: p_before_after => 'A');
799:
800: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
801: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
802: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
803: RAISE OKC_API.G_EXCEPTION_ERROR;
804: END IF;
805: --USER HOOK CALL FOR AFTER, ENDS
806:

Line 803: RAISE OKC_API.G_EXCEPTION_ERROR;

799:
800: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
801: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
802: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
803: RAISE OKC_API.G_EXCEPTION_ERROR;
804: END IF;
805: --USER HOOK CALL FOR AFTER, ENDS
806:
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

803: RAISE OKC_API.G_EXCEPTION_ERROR;
804: END IF;
805: --USER HOOK CALL FOR AFTER, ENDS
806:
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808:
809: EXCEPTION
810: WHEN OKC_API.G_EXCEPTION_ERROR THEN
811: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 810: WHEN OKC_API.G_EXCEPTION_ERROR THEN

806:
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808:
809: EXCEPTION
810: WHEN OKC_API.G_EXCEPTION_ERROR THEN
811: x_return_status := OKC_API.HANDLE_EXCEPTIONS
812: (
813: l_api_name,
814: G_PKG_NAME,

Line 811: x_return_status := OKC_API.HANDLE_EXCEPTIONS

807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808:
809: EXCEPTION
810: WHEN OKC_API.G_EXCEPTION_ERROR THEN
811: x_return_status := OKC_API.HANDLE_EXCEPTIONS
812: (
813: l_api_name,
814: G_PKG_NAME,
815: 'OKC_API.G_RET_STS_ERROR',

Line 815: 'OKC_API.G_RET_STS_ERROR',

811: x_return_status := OKC_API.HANDLE_EXCEPTIONS
812: (
813: l_api_name,
814: G_PKG_NAME,
815: 'OKC_API.G_RET_STS_ERROR',
816: x_msg_count,
817: x_msg_data,
818: '_PUB'
819: );

Line 821: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

817: x_msg_data,
818: '_PUB'
819: );
820:
821: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
822: x_return_status := OKC_API.HANDLE_EXCEPTIONS
823: (
824: l_api_name,
825: G_PKG_NAME,

Line 822: x_return_status := OKC_API.HANDLE_EXCEPTIONS

818: '_PUB'
819: );
820:
821: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
822: x_return_status := OKC_API.HANDLE_EXCEPTIONS
823: (
824: l_api_name,
825: G_PKG_NAME,
826: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 826: 'OKC_API.G_RET_STS_UNEXP_ERROR',

822: x_return_status := OKC_API.HANDLE_EXCEPTIONS
823: (
824: l_api_name,
825: G_PKG_NAME,
826: 'OKC_API.G_RET_STS_UNEXP_ERROR',
827: x_msg_count,
828: x_msg_data,
829: '_PUB'
830: );

Line 833: x_return_status := OKC_API.HANDLE_EXCEPTIONS

829: '_PUB'
830: );
831:
832: WHEN OTHERS THEN
833: x_return_status := OKC_API.HANDLE_EXCEPTIONS
834: (
835: l_api_name,
836: G_PKG_NAME,
837: 'OTHERS',

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

847: x_msg_count OUT NOCOPY NUMBER,
848: x_msg_data OUT NOCOPY VARCHAR2,
849: p_pdfv_tbl IN pdfv_tbl_type) IS
850:
851: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
852: i NUMBER := 0;
853: BEGIN
854: x_return_status := OKC_API.G_RET_STS_SUCCESS;
855: IF p_pdfv_tbl.COUNT > 0 THEN

Line 854: x_return_status := OKC_API.G_RET_STS_SUCCESS;

850:
851: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
852: i NUMBER := 0;
853: BEGIN
854: x_return_status := OKC_API.G_RET_STS_SUCCESS;
855: IF p_pdfv_tbl.COUNT > 0 THEN
856: i := p_pdfv_tbl.FIRST;
857: LOOP
858: delete_proc_def(

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

861: l_return_status,
862: x_msg_count,
863: x_msg_data,
864: p_pdfv_tbl(i));
865: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
866: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
867: x_return_status := l_return_status;
868: raise G_EXCEPTION_HALT_VALIDATION;
869: ELSE

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

862: x_msg_count,
863: x_msg_data,
864: p_pdfv_tbl(i));
865: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
866: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
867: x_return_status := l_return_status;
868: raise G_EXCEPTION_HALT_VALIDATION;
869: ELSE
870: x_return_status := l_return_status;

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

878: WHEN G_EXCEPTION_HALT_VALIDATION THEN
879: NULL;
880:
881: WHEN OTHERS THEN
882: OKC_API.set_message(p_app_name => g_app_name,
883: p_msg_name => g_unexpected_error,
884: p_token1 => g_sqlcode_token,
885: p_token1_value => sqlcode,
886: p_token2 => g_sqlerrm_token,

Line 888: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

884: p_token1 => g_sqlcode_token,
885: p_token1_value => sqlcode,
886: p_token2 => g_sqlerrm_token,
887: p_token2_value => sqlerrm);
888: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
889: END delete_proc_def;
890:
891: PROCEDURE validate_proc_def(p_api_version IN NUMBER,
892: p_init_msg_list IN VARCHAR2 ,

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

896: p_pdfv_rec IN pdfv_rec_type) IS
897:
898: l_api_name CONSTANT VARCHAR2(30) := 'validate_proc_def';
899: l_api_version CONSTANT NUMBER := 1.0;
900: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
901: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
902: BEGIN
903: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
904: g_pkg_name,

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

899: l_api_version CONSTANT NUMBER := 1.0;
900: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
901: l_pdfv_rec pdfv_rec_type := p_pdfv_rec;
902: BEGIN
903: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
904: g_pkg_name,
905: p_init_msg_list,
906: l_api_version,
907: p_api_version,

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

907: p_api_version,
908: '_PUB',
909: x_return_status);
910:
911: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
912: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
913: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
914: RAISE OKC_API.G_EXCEPTION_ERROR;
915: END IF;

Line 912: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

908: '_PUB',
909: x_return_status);
910:
911: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
912: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
913: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
914: RAISE OKC_API.G_EXCEPTION_ERROR;
915: END IF;
916:

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

909: x_return_status);
910:
911: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
912: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
913: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
914: RAISE OKC_API.G_EXCEPTION_ERROR;
915: END IF;
916:
917: -- USER HOOK CALL FOR BEFORE, STARTS

Line 914: RAISE OKC_API.G_EXCEPTION_ERROR;

910:
911: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
912: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
913: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
914: RAISE OKC_API.G_EXCEPTION_ERROR;
915: END IF;
916:
917: -- USER HOOK CALL FOR BEFORE, STARTS
918: g_pdfv_rec := l_pdfv_rec;

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

921: p_package_name => g_pkg_name,
922: p_procedure_name => l_api_name,
923: p_before_after => 'B');
924:
925: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;

Line 926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

922: p_procedure_name => l_api_name,
923: p_before_after => 'B');
924:
925: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;
930:

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

923: p_before_after => 'B');
924:
925: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;
930:
931: --get values back from hook call

Line 928: RAISE OKC_API.G_EXCEPTION_ERROR;

924:
925: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
926: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
927: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
928: RAISE OKC_API.G_EXCEPTION_ERROR;
929: END IF;
930:
931: --get values back from hook call
932: l_pdfv_rec := migrate_pdfv(l_pdfv_rec, g_pdfv_rec);

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

937: x_return_status => x_return_status,
938: x_msg_count => x_msg_count,
939: x_msg_data => x_msg_data,
940: p_pdfv_rec => l_pdfv_rec);
941: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;

Line 942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

938: x_msg_count => x_msg_count,
939: x_msg_data => x_msg_data,
940: p_pdfv_rec => l_pdfv_rec);
941: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;
946:

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

939: x_msg_data => x_msg_data,
940: p_pdfv_rec => l_pdfv_rec);
941: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;
946:
947: --USER HOOK CALL FOR AFTER, STARTS

Line 944: RAISE OKC_API.G_EXCEPTION_ERROR;

940: p_pdfv_rec => l_pdfv_rec);
941: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
942: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
943: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
944: RAISE OKC_API.G_EXCEPTION_ERROR;
945: END IF;
946:
947: --USER HOOK CALL FOR AFTER, STARTS
948:

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

950: p_package_name => g_pkg_name,
951: p_procedure_name => l_api_name,
952: p_before_after => 'A');
953:
954: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
956: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
957: RAISE OKC_API.G_EXCEPTION_ERROR;
958: END IF;

Line 955: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

951: p_procedure_name => l_api_name,
952: p_before_after => 'A');
953:
954: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
956: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
957: RAISE OKC_API.G_EXCEPTION_ERROR;
958: END IF;
959: --USER HOOK CALL FOR AFTER, ENDS

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

952: p_before_after => 'A');
953:
954: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
956: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
957: RAISE OKC_API.G_EXCEPTION_ERROR;
958: END IF;
959: --USER HOOK CALL FOR AFTER, ENDS
960:

Line 957: RAISE OKC_API.G_EXCEPTION_ERROR;

953:
954: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
955: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
956: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
957: RAISE OKC_API.G_EXCEPTION_ERROR;
958: END IF;
959: --USER HOOK CALL FOR AFTER, ENDS
960:
961: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

957: RAISE OKC_API.G_EXCEPTION_ERROR;
958: END IF;
959: --USER HOOK CALL FOR AFTER, ENDS
960:
961: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
962: EXCEPTION
963: WHEN OKC_API.G_EXCEPTION_ERROR THEN
964: x_return_status := OKC_API.HANDLE_EXCEPTIONS
965: (

Line 963: WHEN OKC_API.G_EXCEPTION_ERROR THEN

959: --USER HOOK CALL FOR AFTER, ENDS
960:
961: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
962: EXCEPTION
963: WHEN OKC_API.G_EXCEPTION_ERROR THEN
964: x_return_status := OKC_API.HANDLE_EXCEPTIONS
965: (
966: l_api_name,
967: G_PKG_NAME,

Line 964: x_return_status := OKC_API.HANDLE_EXCEPTIONS

960:
961: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
962: EXCEPTION
963: WHEN OKC_API.G_EXCEPTION_ERROR THEN
964: x_return_status := OKC_API.HANDLE_EXCEPTIONS
965: (
966: l_api_name,
967: G_PKG_NAME,
968: 'OKC_API.G_RET_STS_ERROR',

Line 968: 'OKC_API.G_RET_STS_ERROR',

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

Line 974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

970: x_msg_data,
971: '_PUB'
972: );
973:
974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
975: x_return_status := OKC_API.HANDLE_EXCEPTIONS
976: (
977: l_api_name,
978: G_PKG_NAME,

Line 975: x_return_status := OKC_API.HANDLE_EXCEPTIONS

971: '_PUB'
972: );
973:
974: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
975: x_return_status := OKC_API.HANDLE_EXCEPTIONS
976: (
977: l_api_name,
978: G_PKG_NAME,
979: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 979: 'OKC_API.G_RET_STS_UNEXP_ERROR',

975: x_return_status := OKC_API.HANDLE_EXCEPTIONS
976: (
977: l_api_name,
978: G_PKG_NAME,
979: 'OKC_API.G_RET_STS_UNEXP_ERROR',
980: x_msg_count,
981: x_msg_data,
982: '_PUB'
983: );

Line 986: x_return_status := OKC_API.HANDLE_EXCEPTIONS

982: '_PUB'
983: );
984:
985: WHEN OTHERS THEN
986: x_return_status := OKC_API.HANDLE_EXCEPTIONS
987: (
988: l_api_name,
989: G_PKG_NAME,
990: 'OTHERS',

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

999: x_return_status OUT NOCOPY VARCHAR2,
1000: x_msg_count OUT NOCOPY NUMBER,
1001: x_msg_data OUT NOCOPY VARCHAR2,
1002: p_pdfv_tbl IN pdfv_tbl_type) IS
1003: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1004: i NUMBER := 0;
1005: BEGIN
1006: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1007: IF p_pdfv_tbl.COUNT > 0 THEN

Line 1006: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1002: p_pdfv_tbl IN pdfv_tbl_type) IS
1003: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1004: i NUMBER := 0;
1005: BEGIN
1006: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1007: IF p_pdfv_tbl.COUNT > 0 THEN
1008: i := p_pdfv_tbl.FIRST;
1009: LOOP
1010: validate_proc_def(

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

1013: l_return_status,
1014: x_msg_count,
1015: x_msg_data,
1016: p_pdfv_tbl(i));
1017: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1019: x_return_status := l_return_status;
1020: raise G_EXCEPTION_HALT_VALIDATION;
1021: ELSE

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

1014: x_msg_count,
1015: x_msg_data,
1016: p_pdfv_tbl(i));
1017: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1018: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1019: x_return_status := l_return_status;
1020: raise G_EXCEPTION_HALT_VALIDATION;
1021: ELSE
1022: x_return_status := l_return_status;

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

1030: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1031: NULL;
1032:
1033: WHEN OTHERS THEN
1034: OKC_API.set_message(p_app_name => g_app_name,
1035: p_msg_name => g_unexpected_error,
1036: p_token1 => g_sqlcode_token,
1037: p_token1_value => sqlcode,
1038: p_token2 => g_sqlerrm_token,

Line 1040: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1036: p_token1 => g_sqlcode_token,
1037: p_token1_value => sqlcode,
1038: p_token2 => g_sqlerrm_token,
1039: p_token2_value => sqlerrm);
1040: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1041: END validate_proc_def;
1042:
1043: --Procedures for Process Definition Parameters
1044:

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

1051: x_pdpv_rec OUT NOCOPY pdpv_rec_type) IS
1052:
1053: l_api_name CONSTANT VARCHAR2(30) := 'create_proc_def_parms';
1054: l_api_version CONSTANT NUMBER := 1.0;
1055: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1056: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1057: BEGIN
1058: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1059: g_pkg_name,

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

1054: l_api_version CONSTANT NUMBER := 1.0;
1055: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1056: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1057: BEGIN
1058: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1059: g_pkg_name,
1060: p_init_msg_list,
1061: l_api_version,
1062: p_api_version,

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

1062: p_api_version,
1063: '_PUB',
1064: x_return_status);
1065:
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;

Line 1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1063: '_PUB',
1064: x_return_status);
1065:
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;
1071:

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

1064: x_return_status);
1065:
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;
1071:
1072: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1069: RAISE OKC_API.G_EXCEPTION_ERROR;

1065:
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;
1071:
1072: -- USER HOOK CALL FOR BEFORE, STARTS
1073: g_pdpv_rec := l_pdpv_rec;

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

1076: p_package_name => g_pkg_name,
1077: p_procedure_name => l_api_name,
1078: p_before_after => 'B');
1079:
1080: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1081: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1082: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1083: RAISE OKC_API.G_EXCEPTION_ERROR;
1084: END IF;

Line 1081: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1077: p_procedure_name => l_api_name,
1078: p_before_after => 'B');
1079:
1080: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1081: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1082: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1083: RAISE OKC_API.G_EXCEPTION_ERROR;
1084: END IF;
1085:

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

1078: p_before_after => 'B');
1079:
1080: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1081: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1082: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1083: RAISE OKC_API.G_EXCEPTION_ERROR;
1084: END IF;
1085:
1086: --get values back from hook call

Line 1083: RAISE OKC_API.G_EXCEPTION_ERROR;

1079:
1080: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1081: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1082: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1083: RAISE OKC_API.G_EXCEPTION_ERROR;
1084: END IF;
1085:
1086: --get values back from hook call
1087: l_pdpv_rec := migrate_pdpv(l_pdpv_rec, g_pdpv_rec);

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

1093: x_msg_count => x_msg_count,
1094: x_msg_data => x_msg_data,
1095: p_pdpv_rec => l_pdpv_rec,
1096: x_pdpv_rec => x_pdpv_rec);
1097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1100: RAISE OKC_API.G_EXCEPTION_ERROR;
1101: END IF;

Line 1098: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1094: x_msg_data => x_msg_data,
1095: p_pdpv_rec => l_pdpv_rec,
1096: x_pdpv_rec => x_pdpv_rec);
1097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1100: RAISE OKC_API.G_EXCEPTION_ERROR;
1101: END IF;
1102:

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

1095: p_pdpv_rec => l_pdpv_rec,
1096: x_pdpv_rec => x_pdpv_rec);
1097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1100: RAISE OKC_API.G_EXCEPTION_ERROR;
1101: END IF;
1102:
1103: --USER HOOK CALL FOR AFTER, STARTS

Line 1100: RAISE OKC_API.G_EXCEPTION_ERROR;

1096: x_pdpv_rec => x_pdpv_rec);
1097: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1099: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1100: RAISE OKC_API.G_EXCEPTION_ERROR;
1101: END IF;
1102:
1103: --USER HOOK CALL FOR AFTER, STARTS
1104: g_pdpv_rec := x_pdpv_rec;

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

1107: p_package_name => g_pkg_name,
1108: p_procedure_name => l_api_name,
1109: p_before_after => 'A');
1110:
1111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1112: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1114: RAISE OKC_API.G_EXCEPTION_ERROR;
1115: END IF;

Line 1112: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1108: p_procedure_name => l_api_name,
1109: p_before_after => 'A');
1110:
1111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1112: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1114: RAISE OKC_API.G_EXCEPTION_ERROR;
1115: END IF;
1116: --USER HOOK CALL FOR AFTER, ENDS

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

1109: p_before_after => 'A');
1110:
1111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1112: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1114: RAISE OKC_API.G_EXCEPTION_ERROR;
1115: END IF;
1116: --USER HOOK CALL FOR AFTER, ENDS
1117:

Line 1114: RAISE OKC_API.G_EXCEPTION_ERROR;

1110:
1111: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1112: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1113: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1114: RAISE OKC_API.G_EXCEPTION_ERROR;
1115: END IF;
1116: --USER HOOK CALL FOR AFTER, ENDS
1117:
1118: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1114: RAISE OKC_API.G_EXCEPTION_ERROR;
1115: END IF;
1116: --USER HOOK CALL FOR AFTER, ENDS
1117:
1118: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1119:
1120: EXCEPTION
1121: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1121: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1117:
1118: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1119:
1120: EXCEPTION
1121: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1123: (
1124: l_api_name,
1125: G_PKG_NAME,

Line 1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1118: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1119:
1120: EXCEPTION
1121: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1123: (
1124: l_api_name,
1125: G_PKG_NAME,
1126: 'OKC_API.G_RET_STS_ERROR',

Line 1126: 'OKC_API.G_RET_STS_ERROR',

1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1123: (
1124: l_api_name,
1125: G_PKG_NAME,
1126: 'OKC_API.G_RET_STS_ERROR',
1127: x_msg_count,
1128: x_msg_data,
1129: '_PUB'
1130: );

Line 1132: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1128: x_msg_data,
1129: '_PUB'
1130: );
1131:
1132: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1133: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1134: (
1135: l_api_name,
1136: G_PKG_NAME,

Line 1133: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1129: '_PUB'
1130: );
1131:
1132: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1133: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1134: (
1135: l_api_name,
1136: G_PKG_NAME,
1137: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1137: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1133: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1134: (
1135: l_api_name,
1136: G_PKG_NAME,
1137: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1138: x_msg_count,
1139: x_msg_data,
1140: '_PUB'
1141: );

Line 1144: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1140: '_PUB'
1141: );
1142:
1143: WHEN OTHERS THEN
1144: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1145: (
1146: l_api_name,
1147: G_PKG_NAME,
1148: 'OTHERS',

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

1159: x_msg_data OUT NOCOPY VARCHAR2,
1160: p_pdpv_tbl IN pdpv_tbl_type,
1161: x_pdpv_tbl OUT NOCOPY pdpv_tbl_type) IS
1162:
1163: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1164: i NUMBER := 0;
1165: BEGIN
1166: --Initialize the return status
1167: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1167: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1163: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1164: i NUMBER := 0;
1165: BEGIN
1166: --Initialize the return status
1167: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1168:
1169: IF p_pdpv_tbl.COUNT > 0 THEN
1170: i := p_pdpv_tbl.FIRST;
1171: LOOP

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

1176: x_msg_count,
1177: x_msg_data,
1178: p_pdpv_tbl(i),
1179: x_pdpv_tbl(i));
1180: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1181: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1182: x_return_status := l_return_status;
1183: raise G_EXCEPTION_HALT_VALIDATION;
1184: ELSE

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

1177: x_msg_data,
1178: p_pdpv_tbl(i),
1179: x_pdpv_tbl(i));
1180: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1181: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1182: x_return_status := l_return_status;
1183: raise G_EXCEPTION_HALT_VALIDATION;
1184: ELSE
1185: x_return_status := l_return_status;

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

1193: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1194: NULL;
1195:
1196: WHEN OTHERS THEN
1197: OKC_API.set_message(p_app_name => g_app_name,
1198: p_msg_name => g_unexpected_error,
1199: p_token1 => g_sqlcode_token,
1200: p_token1_value => sqlcode,
1201: p_token2 => g_sqlerrm_token,

Line 1203: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1199: p_token1 => g_sqlcode_token,
1200: p_token1_value => sqlcode,
1201: p_token2 => g_sqlerrm_token,
1202: p_token2_value => sqlerrm);
1203: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1204: END create_proc_def_parms;
1205:
1206: PROCEDURE lock_proc_def_parms(p_api_version IN NUMBER,
1207: p_init_msg_list IN VARCHAR2 ,

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

1210: x_msg_data OUT NOCOPY VARCHAR2,
1211: p_pdpv_rec IN pdpv_rec_type) IS
1212: l_api_name CONSTANT VARCHAR2(30) := 'delete_proc_def_parms';
1213: l_api_version CONSTANT NUMBER := 1.0;
1214: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1215: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1216: BEGIN
1217: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1218: g_pkg_name,

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

1213: l_api_version CONSTANT NUMBER := 1.0;
1214: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1215: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1216: BEGIN
1217: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1218: g_pkg_name,
1219: p_init_msg_list,
1220: l_api_version,
1221: p_api_version,

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

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

Line 1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

1223: x_return_status);
1224:
1225: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1227: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1228: RAISE OKC_API.G_EXCEPTION_ERROR;
1229: END IF;
1230:
1231: -- Call to procedure of complex API

Line 1228: RAISE OKC_API.G_EXCEPTION_ERROR;

1224:
1225: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1226: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1227: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1228: RAISE OKC_API.G_EXCEPTION_ERROR;
1229: END IF;
1230:
1231: -- Call to procedure of complex API
1232: okc_process_pvt.lock_proc_def_parms(p_api_version => p_api_version,

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

1235: x_msg_count => x_msg_count,
1236: x_msg_data => x_msg_data,
1237: p_pdpv_rec => l_pdpv_rec);
1238:
1239: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1240: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1241: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1242: RAISE OKC_API.G_EXCEPTION_ERROR;
1243: END IF;

Line 1240: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1236: x_msg_data => x_msg_data,
1237: p_pdpv_rec => l_pdpv_rec);
1238:
1239: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1240: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1241: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1242: RAISE OKC_API.G_EXCEPTION_ERROR;
1243: END IF;
1244:

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

1237: p_pdpv_rec => l_pdpv_rec);
1238:
1239: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1240: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1241: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1242: RAISE OKC_API.G_EXCEPTION_ERROR;
1243: END IF;
1244:
1245: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1242: RAISE OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 1248: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1244:
1245: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1246:
1247: EXCEPTION
1248: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1249: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1250: (
1251: l_api_name,
1252: G_PKG_NAME,

Line 1249: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1245: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1246:
1247: EXCEPTION
1248: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1249: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1250: (
1251: l_api_name,
1252: G_PKG_NAME,
1253: 'OKC_API.G_RET_STS_ERROR',

Line 1253: 'OKC_API.G_RET_STS_ERROR',

1249: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1250: (
1251: l_api_name,
1252: G_PKG_NAME,
1253: 'OKC_API.G_RET_STS_ERROR',
1254: x_msg_count,
1255: x_msg_data,
1256: '_PUB'
1257: );

Line 1259: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1255: x_msg_data,
1256: '_PUB'
1257: );
1258:
1259: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1260: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1261: (
1262: l_api_name,
1263: G_PKG_NAME,

Line 1260: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1256: '_PUB'
1257: );
1258:
1259: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1260: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1261: (
1262: l_api_name,
1263: G_PKG_NAME,
1264: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1264: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1260: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1261: (
1262: l_api_name,
1263: G_PKG_NAME,
1264: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1265: x_msg_count,
1266: x_msg_data,
1267: '_PUB'
1268: );

Line 1271: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

1284: x_return_status OUT NOCOPY VARCHAR2,
1285: x_msg_count OUT NOCOPY NUMBER,
1286: x_msg_data OUT NOCOPY VARCHAR2,
1287: p_pdpv_tbl IN pdpv_tbl_type) IS
1288: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1289: i NUMBER := 0;
1290: BEGIN
1291: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1292: IF p_pdpv_tbl.COUNT > 0 THEN

Line 1291: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1287: p_pdpv_tbl IN pdpv_tbl_type) IS
1288: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1289: i NUMBER := 0;
1290: BEGIN
1291: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1292: IF p_pdpv_tbl.COUNT > 0 THEN
1293: i := p_pdpv_tbl.FIRST;
1294: LOOP
1295: lock_proc_def_parms(

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

1298: l_return_status,
1299: x_msg_count,
1300: x_msg_data,
1301: p_pdpv_tbl(i));
1302: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1303: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1304: x_return_status := l_return_status;
1305: raise G_EXCEPTION_HALT_VALIDATION;
1306: ELSE

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

1299: x_msg_count,
1300: x_msg_data,
1301: p_pdpv_tbl(i));
1302: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1303: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1304: x_return_status := l_return_status;
1305: raise G_EXCEPTION_HALT_VALIDATION;
1306: ELSE
1307: x_return_status := l_return_status;

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

1315: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1316: NULL;
1317:
1318: WHEN OTHERS THEN
1319: OKC_API.set_message(p_app_name => g_app_name,
1320: p_msg_name => g_unexpected_error,
1321: p_token1 => g_sqlcode_token,
1322: p_token1_value => sqlcode,
1323: p_token2 => g_sqlerrm_token,

Line 1325: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1321: p_token1 => g_sqlcode_token,
1322: p_token1_value => sqlcode,
1323: p_token2 => g_sqlerrm_token,
1324: p_token2_value => sqlerrm);
1325: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1326: End lock_proc_def_parms;
1327:
1328: PROCEDURE update_proc_def_parms(p_api_version IN NUMBER,
1329: p_init_msg_list IN VARCHAR2 ,

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

1334: x_pdpv_rec OUT NOCOPY pdpv_rec_type) IS
1335:
1336: l_api_name CONSTANT VARCHAR2(30) := 'update_proc_def_parms';
1337: l_api_version CONSTANT NUMBER := 1.0;
1338: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1339: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1340: BEGIN
1341: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1342: g_pkg_name,

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

1337: l_api_version CONSTANT NUMBER := 1.0;
1338: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1339: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1340: BEGIN
1341: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1342: g_pkg_name,
1343: p_init_msg_list,
1344: l_api_version,
1345: p_api_version,

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

1344: l_api_version,
1345: p_api_version,
1346: '_PUB',
1347: x_return_status);
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_api_version,
1346: '_PUB',
1347: x_return_status);
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:

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

1346: '_PUB',
1347: x_return_status);
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:
1354: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1351: RAISE OKC_API.G_EXCEPTION_ERROR;

1347: x_return_status);
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:
1354: -- USER HOOK CALL FOR BEFORE, STARTS
1355: g_pdpv_rec := l_pdpv_rec;

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

1357: okc_util.call_user_hook(x_return_status => x_return_status,
1358: p_package_name => g_pkg_name,
1359: p_procedure_name => l_api_name,
1360: p_before_after => 'B');
1361: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;

Line 1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1358: p_package_name => g_pkg_name,
1359: p_procedure_name => l_api_name,
1360: p_before_after => 'B');
1361: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;
1366:

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

1359: p_procedure_name => l_api_name,
1360: p_before_after => 'B');
1361: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;
1366:
1367: --get values back from hook call

Line 1364: RAISE OKC_API.G_EXCEPTION_ERROR;

1360: p_before_after => 'B');
1361: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1362: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1363: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1364: RAISE OKC_API.G_EXCEPTION_ERROR;
1365: END IF;
1366:
1367: --get values back from hook call
1368: l_pdpv_rec := migrate_pdpv(l_pdpv_rec, g_pdpv_rec);

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

1375: x_msg_data => x_msg_data,
1376: p_pdpv_rec => l_pdpv_rec,
1377: x_pdpv_rec => x_pdpv_rec);
1378:
1379: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1380: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1381: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1382: RAISE OKC_API.G_EXCEPTION_ERROR;
1383: END IF;

Line 1380: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1376: p_pdpv_rec => l_pdpv_rec,
1377: x_pdpv_rec => x_pdpv_rec);
1378:
1379: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1380: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1381: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1382: RAISE OKC_API.G_EXCEPTION_ERROR;
1383: END IF;
1384:

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

1377: x_pdpv_rec => x_pdpv_rec);
1378:
1379: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1380: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1381: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1382: RAISE OKC_API.G_EXCEPTION_ERROR;
1383: END IF;
1384:
1385: --USER HOOK CALL FOR AFTER, STARTS

Line 1382: RAISE OKC_API.G_EXCEPTION_ERROR;

1378:
1379: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1380: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1381: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1382: RAISE OKC_API.G_EXCEPTION_ERROR;
1383: END IF;
1384:
1385: --USER HOOK CALL FOR AFTER, STARTS
1386: g_pdpv_rec := x_pdpv_rec;

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

1388: okc_util.call_user_hook(x_return_status => x_return_status,
1389: p_package_name => g_pkg_name,
1390: p_procedure_name => l_api_name,
1391: p_before_after => 'A');
1392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1395: RAISE OKC_API.G_EXCEPTION_ERROR;
1396: END IF;

Line 1393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1389: p_package_name => g_pkg_name,
1390: p_procedure_name => l_api_name,
1391: p_before_after => 'A');
1392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1395: RAISE OKC_API.G_EXCEPTION_ERROR;
1396: END IF;
1397: --USER HOOK CALL FOR AFTER, ENDS

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

1390: p_procedure_name => l_api_name,
1391: p_before_after => 'A');
1392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1395: RAISE OKC_API.G_EXCEPTION_ERROR;
1396: END IF;
1397: --USER HOOK CALL FOR AFTER, ENDS
1398:

Line 1395: RAISE OKC_API.G_EXCEPTION_ERROR;

1391: p_before_after => 'A');
1392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1395: RAISE OKC_API.G_EXCEPTION_ERROR;
1396: END IF;
1397: --USER HOOK CALL FOR AFTER, ENDS
1398:
1399: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1395: RAISE OKC_API.G_EXCEPTION_ERROR;
1396: END IF;
1397: --USER HOOK CALL FOR AFTER, ENDS
1398:
1399: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1400:
1401: EXCEPTION
1402: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1403: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1402: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

Line 1403: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 1407: 'OKC_API.G_RET_STS_ERROR',

1403: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1404: (
1405: l_api_name,
1406: G_PKG_NAME,
1407: 'OKC_API.G_RET_STS_ERROR',
1408: x_msg_count,
1409: x_msg_data,
1410: '_PUB'
1411: );

Line 1413: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1409: x_msg_data,
1410: '_PUB'
1411: );
1412:
1413: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1414: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1415: (
1416: l_api_name,
1417: G_PKG_NAME,

Line 1414: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1410: '_PUB'
1411: );
1412:
1413: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1414: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1415: (
1416: l_api_name,
1417: G_PKG_NAME,
1418: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1418: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1414: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1415: (
1416: l_api_name,
1417: G_PKG_NAME,
1418: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1419: x_msg_count,
1420: x_msg_data,
1421: '_PUB'
1422: );

Line 1425: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1421: '_PUB'
1422: );
1423:
1424: WHEN OTHERS THEN
1425: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1426: (
1427: l_api_name,
1428: G_PKG_NAME,
1429: 'OTHERS',

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

1440: x_msg_data OUT NOCOPY VARCHAR2,
1441: p_pdpv_tbl IN pdpv_tbl_type,
1442: x_pdpv_tbl OUT NOCOPY pdpv_tbl_type) IS
1443:
1444: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1445: i NUMBER := 0;
1446: BEGIN
1447: --Initialize the return status
1448: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1448: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1444: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1445: i NUMBER := 0;
1446: BEGIN
1447: --Initialize the return status
1448: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1449:
1450: IF p_pdpv_tbl.COUNT > 0 THEN
1451: i := p_pdpv_tbl.FIRST;
1452: LOOP

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

1457: x_msg_count,
1458: x_msg_data,
1459: p_pdpv_tbl(i),
1460: x_pdpv_tbl(i));
1461: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1462: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1463: x_return_status := l_return_status;
1464: raise G_EXCEPTION_HALT_VALIDATION;
1465: ELSE

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

1458: x_msg_data,
1459: p_pdpv_tbl(i),
1460: x_pdpv_tbl(i));
1461: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1462: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1463: x_return_status := l_return_status;
1464: raise G_EXCEPTION_HALT_VALIDATION;
1465: ELSE
1466: x_return_status := l_return_status;

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

1474: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1475: NULL;
1476:
1477: WHEN OTHERS THEN
1478: OKC_API.set_message(p_app_name => g_app_name,
1479: p_msg_name => g_unexpected_error,
1480: p_token1 => g_sqlcode_token,
1481: p_token1_value => sqlcode,
1482: p_token2 => g_sqlerrm_token,

Line 1484: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1480: p_token1 => g_sqlcode_token,
1481: p_token1_value => sqlcode,
1482: p_token2 => g_sqlerrm_token,
1483: p_token2_value => sqlerrm);
1484: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1485: END update_proc_def_parms;
1486:
1487: PROCEDURE delete_proc_def_parms(p_api_version IN NUMBER,
1488: p_init_msg_list IN VARCHAR2 ,

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

1492: p_pdpv_rec IN pdpv_rec_type) IS
1493:
1494: l_api_name CONSTANT VARCHAR2(30) := 'delete_proc_def_parms';
1495: l_api_version CONSTANT NUMBER := 1.0;
1496: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1497: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1498: BEGIN
1499: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1500: g_pkg_name,

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

1495: l_api_version CONSTANT NUMBER := 1.0;
1496: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1497: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1498: BEGIN
1499: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1500: g_pkg_name,
1501: p_init_msg_list,
1502: l_api_version,
1503: p_api_version,

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

1503: p_api_version,
1504: '_PUB',
1505: x_return_status);
1506:
1507: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1508: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1509: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1510: RAISE OKC_API.G_EXCEPTION_ERROR;
1511: END IF;

Line 1508: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1504: '_PUB',
1505: x_return_status);
1506:
1507: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1508: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1509: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1510: RAISE OKC_API.G_EXCEPTION_ERROR;
1511: END IF;
1512:

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

1505: x_return_status);
1506:
1507: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1508: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1509: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1510: RAISE OKC_API.G_EXCEPTION_ERROR;
1511: END IF;
1512:
1513: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1510: RAISE OKC_API.G_EXCEPTION_ERROR;

1506:
1507: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1508: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1509: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1510: RAISE OKC_API.G_EXCEPTION_ERROR;
1511: END IF;
1512:
1513: -- USER HOOK CALL FOR BEFORE, STARTS
1514: g_pdpv_rec := l_pdpv_rec;

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

1516: okc_util.call_user_hook(x_return_status => x_return_status,
1517: p_package_name => g_pkg_name,
1518: p_procedure_name => l_api_name,
1519: p_before_after => 'B');
1520: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1522: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_ERROR;
1524: END IF;

Line 1521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1517: p_package_name => g_pkg_name,
1518: p_procedure_name => l_api_name,
1519: p_before_after => 'B');
1520: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1522: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_ERROR;
1524: END IF;
1525:

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

1518: p_procedure_name => l_api_name,
1519: p_before_after => 'B');
1520: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1522: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_ERROR;
1524: END IF;
1525:
1526: --get values back from hook call

Line 1523: RAISE OKC_API.G_EXCEPTION_ERROR;

1519: p_before_after => 'B');
1520: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1521: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1522: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1523: RAISE OKC_API.G_EXCEPTION_ERROR;
1524: END IF;
1525:
1526: --get values back from hook call
1527: l_pdpv_rec := migrate_pdpv(l_pdpv_rec, g_pdpv_rec);

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

1532: x_return_status => x_return_status,
1533: x_msg_count => x_msg_count,
1534: x_msg_data => x_msg_data,
1535: p_pdpv_rec => l_pdpv_rec);
1536: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1537: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1538: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1539: RAISE OKC_API.G_EXCEPTION_ERROR;
1540: END IF;

Line 1537: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1533: x_msg_count => x_msg_count,
1534: x_msg_data => x_msg_data,
1535: p_pdpv_rec => l_pdpv_rec);
1536: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1537: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1538: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1539: RAISE OKC_API.G_EXCEPTION_ERROR;
1540: END IF;
1541:

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

1534: x_msg_data => x_msg_data,
1535: p_pdpv_rec => l_pdpv_rec);
1536: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1537: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1538: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1539: RAISE OKC_API.G_EXCEPTION_ERROR;
1540: END IF;
1541:
1542: --USER HOOK CALL FOR AFTER, STARTS

Line 1539: RAISE OKC_API.G_EXCEPTION_ERROR;

1535: p_pdpv_rec => l_pdpv_rec);
1536: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1537: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1538: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1539: RAISE OKC_API.G_EXCEPTION_ERROR;
1540: END IF;
1541:
1542: --USER HOOK CALL FOR AFTER, STARTS
1543: okc_util.call_user_hook(x_return_status => x_return_status,

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

1544: p_package_name => g_pkg_name,
1545: p_procedure_name => l_api_name,
1546: p_before_after => 'A');
1547:
1548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1549: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1551: RAISE OKC_API.G_EXCEPTION_ERROR;
1552: END IF;

Line 1549: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1545: p_procedure_name => l_api_name,
1546: p_before_after => 'A');
1547:
1548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1549: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1551: RAISE OKC_API.G_EXCEPTION_ERROR;
1552: END IF;
1553: --USER HOOK CALL FOR AFTER, ENDS

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

1546: p_before_after => 'A');
1547:
1548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1549: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1551: RAISE OKC_API.G_EXCEPTION_ERROR;
1552: END IF;
1553: --USER HOOK CALL FOR AFTER, ENDS
1554:

Line 1551: RAISE OKC_API.G_EXCEPTION_ERROR;

1547:
1548: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1549: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1550: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1551: RAISE OKC_API.G_EXCEPTION_ERROR;
1552: END IF;
1553: --USER HOOK CALL FOR AFTER, ENDS
1554:
1555: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1551: RAISE OKC_API.G_EXCEPTION_ERROR;
1552: END IF;
1553: --USER HOOK CALL FOR AFTER, ENDS
1554:
1555: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1556: EXCEPTION
1557: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1558: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1559: (

Line 1557: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1553: --USER HOOK CALL FOR AFTER, ENDS
1554:
1555: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1556: EXCEPTION
1557: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1558: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1559: (
1560: l_api_name,
1561: G_PKG_NAME,

Line 1558: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1554:
1555: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1556: EXCEPTION
1557: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1558: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1559: (
1560: l_api_name,
1561: G_PKG_NAME,
1562: 'OKC_API.G_RET_STS_ERROR',

Line 1562: 'OKC_API.G_RET_STS_ERROR',

1558: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1559: (
1560: l_api_name,
1561: G_PKG_NAME,
1562: 'OKC_API.G_RET_STS_ERROR',
1563: x_msg_count,
1564: x_msg_data,
1565: '_PUB'
1566: );

Line 1568: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1564: x_msg_data,
1565: '_PUB'
1566: );
1567:
1568: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1569: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1570: (
1571: l_api_name,
1572: G_PKG_NAME,

Line 1569: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1565: '_PUB'
1566: );
1567:
1568: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1569: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1570: (
1571: l_api_name,
1572: G_PKG_NAME,
1573: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1573: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1569: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1570: (
1571: l_api_name,
1572: G_PKG_NAME,
1573: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1574: x_msg_count,
1575: x_msg_data,
1576: '_PUB'
1577: );

Line 1580: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1576: '_PUB'
1577: );
1578:
1579: WHEN OTHERS THEN
1580: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1581: (
1582: l_api_name,
1583: G_PKG_NAME,
1584: 'OTHERS',

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

1594: x_msg_count OUT NOCOPY NUMBER,
1595: x_msg_data OUT NOCOPY VARCHAR2,
1596: p_pdpv_tbl IN pdpv_tbl_type) IS
1597:
1598: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1599: i NUMBER := 0;
1600: BEGIN
1601: --Initialize the return status
1602: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1602: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1598: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1599: i NUMBER := 0;
1600: BEGIN
1601: --Initialize the return status
1602: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1603:
1604: IF p_pdpv_tbl.COUNT > 0 THEN
1605: i := p_pdpv_tbl.FIRST;
1606: LOOP

Line 1614: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1610: x_return_status,
1611: x_msg_count,
1612: x_msg_data,
1613: p_pdpv_tbl(i));
1614: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1615: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
1616: l_return_status := x_return_status;
1617: RAISE G_EXCEPTION_HALT_VALIDATION;
1618: ELSE

Line 1615: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave

1611: x_msg_count,
1612: x_msg_data,
1613: p_pdpv_tbl(i));
1614: IF (x_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1615: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN -- need to leave
1616: l_return_status := x_return_status;
1617: RAISE G_EXCEPTION_HALT_VALIDATION;
1618: ELSE
1619: l_return_status := x_return_status; -- record that there was an error

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

1627: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1628: NULL;
1629:
1630: WHEN OTHERS THEN
1631: OKC_API.set_message(p_app_name => g_app_name,
1632: p_msg_name => g_unexpected_error,
1633: p_token1 => g_sqlcode_token,
1634: p_token1_value => sqlcode,
1635: p_token2 => g_sqlerrm_token,

Line 1637: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1633: p_token1 => g_sqlcode_token,
1634: p_token1_value => sqlcode,
1635: p_token2 => g_sqlerrm_token,
1636: p_token2_value => sqlerrm);
1637: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1638: END delete_proc_def_parms;
1639:
1640: PROCEDURE validate_proc_def_parms(p_api_version IN NUMBER,
1641: p_init_msg_list IN VARCHAR2 ,

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

1645: p_pdpv_rec IN pdpv_rec_type) IS
1646:
1647: l_api_name CONSTANT VARCHAR2(30) := 'validate_proc_def_parms';
1648: l_api_version CONSTANT NUMBER := 1.0;
1649: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1650: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1651: BEGIN
1652: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1653: g_pkg_name,

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

1648: l_api_version CONSTANT NUMBER := 1.0;
1649: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1650: l_pdpv_rec pdpv_rec_type := p_pdpv_rec;
1651: BEGIN
1652: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1653: g_pkg_name,
1654: p_init_msg_list,
1655: l_api_version,
1656: p_api_version,

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

1656: p_api_version,
1657: '_PUB',
1658: x_return_status);
1659:
1660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1663: RAISE OKC_API.G_EXCEPTION_ERROR;
1664: END IF;

Line 1661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1657: '_PUB',
1658: x_return_status);
1659:
1660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1663: RAISE OKC_API.G_EXCEPTION_ERROR;
1664: END IF;
1665:

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

1658: x_return_status);
1659:
1660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1663: RAISE OKC_API.G_EXCEPTION_ERROR;
1664: END IF;
1665:
1666: -- USER HOOK CALL FOR BEFORE, STARTS

Line 1663: RAISE OKC_API.G_EXCEPTION_ERROR;

1659:
1660: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1661: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1662: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1663: RAISE OKC_API.G_EXCEPTION_ERROR;
1664: END IF;
1665:
1666: -- USER HOOK CALL FOR BEFORE, STARTS
1667: g_pdpv_rec := l_pdpv_rec;

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

1669: okc_util.call_user_hook(x_return_status => x_return_status,
1670: p_package_name => g_pkg_name,
1671: p_procedure_name => l_api_name,
1672: p_before_after => 'B');
1673: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1675: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1676: RAISE OKC_API.G_EXCEPTION_ERROR;
1677: END IF;

Line 1674: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1670: p_package_name => g_pkg_name,
1671: p_procedure_name => l_api_name,
1672: p_before_after => 'B');
1673: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1675: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1676: RAISE OKC_API.G_EXCEPTION_ERROR;
1677: END IF;
1678:

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

1671: p_procedure_name => l_api_name,
1672: p_before_after => 'B');
1673: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1675: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1676: RAISE OKC_API.G_EXCEPTION_ERROR;
1677: END IF;
1678:
1679: --get values back from hook call

Line 1676: RAISE OKC_API.G_EXCEPTION_ERROR;

1672: p_before_after => 'B');
1673: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1674: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1675: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1676: RAISE OKC_API.G_EXCEPTION_ERROR;
1677: END IF;
1678:
1679: --get values back from hook call
1680: l_pdpv_rec := migrate_pdpv(l_pdpv_rec, g_pdpv_rec);

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

1686: x_msg_count => x_msg_count,
1687: x_msg_data => x_msg_data,
1688: p_pdpv_rec => l_pdpv_rec);
1689:
1690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1691: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_ERROR;
1694: END IF;

Line 1691: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1687: x_msg_data => x_msg_data,
1688: p_pdpv_rec => l_pdpv_rec);
1689:
1690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1691: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_ERROR;
1694: END IF;
1695:

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

1688: p_pdpv_rec => l_pdpv_rec);
1689:
1690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1691: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_ERROR;
1694: END IF;
1695:
1696: --USER HOOK CALL FOR AFTER, STARTS

Line 1693: RAISE OKC_API.G_EXCEPTION_ERROR;

1689:
1690: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1691: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1692: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1693: RAISE OKC_API.G_EXCEPTION_ERROR;
1694: END IF;
1695:
1696: --USER HOOK CALL FOR AFTER, STARTS
1697: okc_util.call_user_hook(x_return_status => x_return_status,

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

1697: okc_util.call_user_hook(x_return_status => x_return_status,
1698: p_package_name => g_pkg_name,
1699: p_procedure_name => l_api_name,
1700: p_before_after => 'A');
1701: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1702: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1703: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1704: RAISE OKC_API.G_EXCEPTION_ERROR;
1705: END IF;

Line 1702: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1698: p_package_name => g_pkg_name,
1699: p_procedure_name => l_api_name,
1700: p_before_after => 'A');
1701: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1702: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1703: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1704: RAISE OKC_API.G_EXCEPTION_ERROR;
1705: END IF;
1706: --USER HOOK CALL FOR AFTER, ENDS

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

1699: p_procedure_name => l_api_name,
1700: p_before_after => 'A');
1701: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1702: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1703: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1704: RAISE OKC_API.G_EXCEPTION_ERROR;
1705: END IF;
1706: --USER HOOK CALL FOR AFTER, ENDS
1707:

Line 1704: RAISE OKC_API.G_EXCEPTION_ERROR;

1700: p_before_after => 'A');
1701: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1702: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1703: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1704: RAISE OKC_API.G_EXCEPTION_ERROR;
1705: END IF;
1706: --USER HOOK CALL FOR AFTER, ENDS
1707:
1708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1704: RAISE OKC_API.G_EXCEPTION_ERROR;
1705: END IF;
1706: --USER HOOK CALL FOR AFTER, ENDS
1707:
1708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1709:
1710: EXCEPTION
1711: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1712: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 1711: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

Line 1712: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1709:
1710: EXCEPTION
1711: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1712: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1713: (
1714: l_api_name,
1715: G_PKG_NAME,
1716: 'OKC_API.G_RET_STS_ERROR',

Line 1716: 'OKC_API.G_RET_STS_ERROR',

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

Line 1722: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 1723: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1719: '_PUB'
1720: );
1721:
1722: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1723: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1724: (
1725: l_api_name,
1726: G_PKG_NAME,
1727: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1727: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1723: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1724: (
1725: l_api_name,
1726: G_PKG_NAME,
1727: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1728: x_msg_count,
1729: x_msg_data,
1730: '_PUB'
1731: );

Line 1734: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1730: '_PUB'
1731: );
1732:
1733: WHEN OTHERS THEN
1734: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1735: (
1736: l_api_name,
1737: G_PKG_NAME,
1738: 'OTHERS',

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

1748: x_msg_count OUT NOCOPY NUMBER,
1749: x_msg_data OUT NOCOPY VARCHAR2,
1750: p_pdpv_tbl IN pdpv_tbl_type) IS
1751:
1752: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1753: i NUMBER := 0;
1754: BEGIN
1755: --Initialize the return status
1756: x_return_status := OKC_API.G_RET_STS_SUCCESS;

Line 1756: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1752: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1753: i NUMBER := 0;
1754: BEGIN
1755: --Initialize the return status
1756: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1757:
1758: IF p_pdpv_tbl.COUNT > 0 THEN
1759: i := p_pdpv_tbl.FIRST;
1760: LOOP

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

1764: l_return_status,
1765: x_msg_count,
1766: x_msg_data,
1767: p_pdpv_tbl(i));
1768: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1769: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1770: x_return_status := l_return_status;
1771: raise G_EXCEPTION_HALT_VALIDATION;
1772: ELSE

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

1765: x_msg_count,
1766: x_msg_data,
1767: p_pdpv_tbl(i));
1768: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1769: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1770: x_return_status := l_return_status;
1771: raise G_EXCEPTION_HALT_VALIDATION;
1772: ELSE
1773: x_return_status := l_return_status;

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

1781: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1782: NULL;
1783:
1784: WHEN OTHERS THEN
1785: OKC_API.set_message(p_app_name => g_app_name,
1786: p_msg_name => g_unexpected_error,
1787: p_token1 => g_sqlcode_token,
1788: p_token1_value => sqlcode,
1789: p_token2 => g_sqlerrm_token,

Line 1791: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1787: p_token1 => g_sqlcode_token,
1788: p_token1_value => sqlcode,
1789: p_token2 => g_sqlerrm_token,
1790: p_token2_value => sqlerrm);
1791: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1792: END validate_proc_def_parms;
1793:
1794: /* -----------------------------------------------------------------------------------------
1795: PROCEDURE: validate_dbnames

Line 1838: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1834: x_msg_data,
1835: l_pdfv_rec);
1836:
1837: EXCEPTION
1838: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1839: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1840: (l_api_name,
1841: G_PKG_NAME,
1842: 'OKC_API.G_RET_STS_ERROR',

Line 1839: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1835: l_pdfv_rec);
1836:
1837: EXCEPTION
1838: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1839: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1840: (l_api_name,
1841: G_PKG_NAME,
1842: 'OKC_API.G_RET_STS_ERROR',
1843: x_msg_count,

Line 1842: 'OKC_API.G_RET_STS_ERROR',

1838: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1839: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1840: (l_api_name,
1841: G_PKG_NAME,
1842: 'OKC_API.G_RET_STS_ERROR',
1843: x_msg_count,
1844: x_msg_data,
1845: '_PUB');
1846: APP_EXCEPTION.raise_exception;

Line 1848: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1844: x_msg_data,
1845: '_PUB');
1846: APP_EXCEPTION.raise_exception;
1847:
1848: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1849: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1850: (l_api_name,
1851: G_PKG_NAME,
1852: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1849: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1845: '_PUB');
1846: APP_EXCEPTION.raise_exception;
1847:
1848: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1849: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1850: (l_api_name,
1851: G_PKG_NAME,
1852: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1853: x_msg_count,

Line 1852: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1848: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1849: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1850: (l_api_name,
1851: G_PKG_NAME,
1852: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1853: x_msg_count,
1854: x_msg_data,
1855: '_PUB');
1856: APP_EXCEPTION.raise_exception;