APPS.OKC_TIME_PUB dependencies on OKC_API

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

111: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_TPA_RELTV';
112: l_return_status VARCHAR2(1);
113: l_talv_rec talv_rec_type := p_talv_rec;
114: BEGIN
115: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
116: p_init_msg_list,
117: '_PUB',
118: x_return_status);
119: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

115: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
116: p_init_msg_list,
117: '_PUB',
118: x_return_status);
119: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
121: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
122: raise OKC_API.G_EXCEPTION_ERROR;
123: END IF;

Line 120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

116: p_init_msg_list,
117: '_PUB',
118: x_return_status);
119: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
121: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
122: raise OKC_API.G_EXCEPTION_ERROR;
123: END IF;
124: -- Call user hook for BEFORE

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

117: '_PUB',
118: x_return_status);
119: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
121: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
122: raise OKC_API.G_EXCEPTION_ERROR;
123: END IF;
124: -- Call user hook for BEFORE
125: g_talv_rec := l_talv_rec;

Line 122: raise OKC_API.G_EXCEPTION_ERROR;

118: x_return_status);
119: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
121: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
122: raise OKC_API.G_EXCEPTION_ERROR;
123: END IF;
124: -- Call user hook for BEFORE
125: g_talv_rec := l_talv_rec;
126: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

123: END IF;
124: -- Call user hook for BEFORE
125: g_talv_rec := l_talv_rec;
126: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
127: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
128: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
129: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
130: raise OKC_API.G_EXCEPTION_ERROR;
131: END IF;

Line 128: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

124: -- Call user hook for BEFORE
125: g_talv_rec := l_talv_rec;
126: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
127: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
128: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
129: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
130: raise OKC_API.G_EXCEPTION_ERROR;
131: END IF;
132: l_talv_rec := migrate_talv(l_talv_rec, g_talv_rec);

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

125: g_talv_rec := l_talv_rec;
126: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
127: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
128: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
129: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
130: raise OKC_API.G_EXCEPTION_ERROR;
131: END IF;
132: l_talv_rec := migrate_talv(l_talv_rec, g_talv_rec);
133: OKC_TIME_PVT.CREATE_TPA_RELTV(

Line 130: raise OKC_API.G_EXCEPTION_ERROR;

126: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
127: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
128: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
129: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
130: raise OKC_API.G_EXCEPTION_ERROR;
131: END IF;
132: l_talv_rec := migrate_talv(l_talv_rec, g_talv_rec);
133: OKC_TIME_PVT.CREATE_TPA_RELTV(
134: p_api_version,

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

137: x_msg_count,
138: x_msg_data,
139: p_talv_rec,
140: x_talv_rec);
141: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
142: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
143: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
144: raise OKC_API.G_EXCEPTION_ERROR;
145: END IF;

Line 142: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

138: x_msg_data,
139: p_talv_rec,
140: x_talv_rec);
141: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
142: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
143: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
144: raise OKC_API.G_EXCEPTION_ERROR;
145: END IF;
146:

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

139: p_talv_rec,
140: x_talv_rec);
141: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
142: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
143: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
144: raise OKC_API.G_EXCEPTION_ERROR;
145: END IF;
146:
147: -- Call user hook for AFTER

Line 144: raise OKC_API.G_EXCEPTION_ERROR;

140: x_talv_rec);
141: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
142: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
143: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
144: raise OKC_API.G_EXCEPTION_ERROR;
145: END IF;
146:
147: -- Call user hook for AFTER
148: g_talv_rec := x_talv_rec;

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

146:
147: -- Call user hook for AFTER
148: g_talv_rec := x_talv_rec;
149: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
150: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
151: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
152: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
153: raise OKC_API.G_EXCEPTION_ERROR;
154: END IF;

Line 151: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

147: -- Call user hook for AFTER
148: g_talv_rec := x_talv_rec;
149: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
150: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
151: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
152: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
153: raise OKC_API.G_EXCEPTION_ERROR;
154: END IF;
155: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

148: g_talv_rec := x_talv_rec;
149: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
150: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
151: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
152: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
153: raise OKC_API.G_EXCEPTION_ERROR;
154: END IF;
155: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
156: EXCEPTION

Line 153: raise OKC_API.G_EXCEPTION_ERROR;

149: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
150: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
151: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
152: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
153: raise OKC_API.G_EXCEPTION_ERROR;
154: END IF;
155: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
156: EXCEPTION
157: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

151: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
152: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
153: raise OKC_API.G_EXCEPTION_ERROR;
154: END IF;
155: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
156: EXCEPTION
157: WHEN OKC_API.G_EXCEPTION_ERROR THEN
158: x_return_status := OKC_API.HANDLE_EXCEPTIONS
159: (l_api_name,

Line 157: WHEN OKC_API.G_EXCEPTION_ERROR THEN

153: raise OKC_API.G_EXCEPTION_ERROR;
154: END IF;
155: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
156: EXCEPTION
157: WHEN OKC_API.G_EXCEPTION_ERROR THEN
158: x_return_status := OKC_API.HANDLE_EXCEPTIONS
159: (l_api_name,
160: G_PKG_NAME,
161: 'OKC_API.G_RET_STS_ERROR',

Line 158: x_return_status := OKC_API.HANDLE_EXCEPTIONS

154: END IF;
155: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
156: EXCEPTION
157: WHEN OKC_API.G_EXCEPTION_ERROR THEN
158: x_return_status := OKC_API.HANDLE_EXCEPTIONS
159: (l_api_name,
160: G_PKG_NAME,
161: 'OKC_API.G_RET_STS_ERROR',
162: x_msg_count,

Line 161: 'OKC_API.G_RET_STS_ERROR',

157: WHEN OKC_API.G_EXCEPTION_ERROR THEN
158: x_return_status := OKC_API.HANDLE_EXCEPTIONS
159: (l_api_name,
160: G_PKG_NAME,
161: 'OKC_API.G_RET_STS_ERROR',
162: x_msg_count,
163: x_msg_data,
164: '_PUB');
165: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 165: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

161: 'OKC_API.G_RET_STS_ERROR',
162: x_msg_count,
163: x_msg_data,
164: '_PUB');
165: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
166: x_return_status := OKC_API.HANDLE_EXCEPTIONS
167: (l_api_name,
168: G_PKG_NAME,
169: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 166: x_return_status := OKC_API.HANDLE_EXCEPTIONS

162: x_msg_count,
163: x_msg_data,
164: '_PUB');
165: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
166: x_return_status := OKC_API.HANDLE_EXCEPTIONS
167: (l_api_name,
168: G_PKG_NAME,
169: 'OKC_API.G_RET_STS_UNEXP_ERROR',
170: x_msg_count,

Line 169: 'OKC_API.G_RET_STS_UNEXP_ERROR',

165: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
166: x_return_status := OKC_API.HANDLE_EXCEPTIONS
167: (l_api_name,
168: G_PKG_NAME,
169: 'OKC_API.G_RET_STS_UNEXP_ERROR',
170: x_msg_count,
171: x_msg_data,
172: '_PUB');
173: WHEN OTHERS THEN

Line 174: x_return_status := OKC_API.HANDLE_EXCEPTIONS

170: x_msg_count,
171: x_msg_data,
172: '_PUB');
173: WHEN OTHERS THEN
174: x_return_status := OKC_API.HANDLE_EXCEPTIONS
175: (l_api_name,
176: G_PKG_NAME,
177: 'OTHERS',
178: x_msg_count,

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

188: x_msg_data OUT NOCOPY VARCHAR2,
189: p_talv_tbl IN talv_tbl_type,
190: x_talv_tbl OUT NOCOPY talv_tbl_type) IS
191: i NUMBER := 0;
192: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
193: BEGIN
194: x_return_status := OKC_API.G_RET_STS_SUCCESS;
195: IF p_talv_tbl.COUNT > 0 THEN
196: i := p_talv_tbl.FIRST;

Line 194: x_return_status := OKC_API.G_RET_STS_SUCCESS;

190: x_talv_tbl OUT NOCOPY talv_tbl_type) IS
191: i NUMBER := 0;
192: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
193: BEGIN
194: x_return_status := OKC_API.G_RET_STS_SUCCESS;
195: IF p_talv_tbl.COUNT > 0 THEN
196: i := p_talv_tbl.FIRST;
197: LOOP
198: CREATE_TPA_RELTV(

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

202: x_msg_count,
203: x_msg_data,
204: p_talv_tbl(i),
205: x_talv_tbl(i));
206: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
207: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
208: x_return_status := l_return_status;
209: raise G_EXCEPTION_HALT_VALIDATION;
210: ELSE

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

203: x_msg_data,
204: p_talv_tbl(i),
205: x_talv_tbl(i));
206: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
207: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
208: x_return_status := l_return_status;
209: raise G_EXCEPTION_HALT_VALIDATION;
210: ELSE
211: x_return_status := l_return_status;

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

218: EXCEPTION
219: WHEN G_EXCEPTION_HALT_VALIDATION THEN
220: NULL;
221: WHEN OTHERS THEN
222: OKC_API.set_message(p_app_name => g_app_name,
223: p_msg_name => g_unexpected_error,
224: p_token1 => g_sqlcode_token,
225: p_token1_value => sqlcode,
226: p_token2 => g_sqlerrm_token,

Line 228: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

224: p_token1 => g_sqlcode_token,
225: p_token1_value => sqlcode,
226: p_token2 => g_sqlerrm_token,
227: p_token2_value => sqlerrm);
228: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
229: END CREATE_TPA_RELTV;
230:
231: PROCEDURE UPDATE_TPA_RELTV(
232: p_api_version IN NUMBER,

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

239: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_TPA_RELTV';
240: l_return_status VARCHAR2(1);
241: l_talv_rec talv_rec_type := p_talv_rec;
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: -- Call user hook for BEFORE

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: -- Call user hook for BEFORE
253: g_talv_rec := l_talv_rec;

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: -- Call user hook for BEFORE
253: g_talv_rec := l_talv_rec;
254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

251: END IF;
252: -- Call user hook for BEFORE
253: g_talv_rec := l_talv_rec;
254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
258: raise OKC_API.G_EXCEPTION_ERROR;
259: END IF;

Line 256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

252: -- Call user hook for BEFORE
253: g_talv_rec := l_talv_rec;
254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
258: raise OKC_API.G_EXCEPTION_ERROR;
259: END IF;
260: l_talv_rec := migrate_talv(l_talv_rec, g_talv_rec);

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

253: g_talv_rec := l_talv_rec;
254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
258: raise OKC_API.G_EXCEPTION_ERROR;
259: END IF;
260: l_talv_rec := migrate_talv(l_talv_rec, g_talv_rec);
261: OKC_TIME_PVT.UPDATE_TPA_RELTV(

Line 258: raise OKC_API.G_EXCEPTION_ERROR;

254: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
255: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
256: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
257: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
258: raise OKC_API.G_EXCEPTION_ERROR;
259: END IF;
260: l_talv_rec := migrate_talv(l_talv_rec, g_talv_rec);
261: OKC_TIME_PVT.UPDATE_TPA_RELTV(
262: p_api_version,

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

265: x_msg_count,
266: x_msg_data,
267: p_talv_rec,
268: x_talv_rec);
269: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
271: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
272: raise OKC_API.G_EXCEPTION_ERROR;
273: END IF;

Line 270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

266: x_msg_data,
267: p_talv_rec,
268: x_talv_rec);
269: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
271: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
272: raise OKC_API.G_EXCEPTION_ERROR;
273: END IF;
274:

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

267: p_talv_rec,
268: x_talv_rec);
269: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
271: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
272: raise OKC_API.G_EXCEPTION_ERROR;
273: END IF;
274:
275: -- Call user hook for AFTER

Line 272: raise OKC_API.G_EXCEPTION_ERROR;

268: x_talv_rec);
269: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
271: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
272: raise OKC_API.G_EXCEPTION_ERROR;
273: END IF;
274:
275: -- Call user hook for AFTER
276: g_talv_rec := x_talv_rec;

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

274:
275: -- Call user hook for AFTER
276: g_talv_rec := x_talv_rec;
277: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;

Line 279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

275: -- Call user hook for AFTER
276: g_talv_rec := x_talv_rec;
277: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

276: g_talv_rec := x_talv_rec;
277: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
284: EXCEPTION

Line 281: raise OKC_API.G_EXCEPTION_ERROR;

277: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
278: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
284: EXCEPTION
285: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

279: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
280: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
284: EXCEPTION
285: WHEN OKC_API.G_EXCEPTION_ERROR THEN
286: x_return_status := OKC_API.HANDLE_EXCEPTIONS
287: (l_api_name,

Line 285: WHEN OKC_API.G_EXCEPTION_ERROR THEN

281: raise OKC_API.G_EXCEPTION_ERROR;
282: END IF;
283: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
284: EXCEPTION
285: WHEN OKC_API.G_EXCEPTION_ERROR THEN
286: x_return_status := OKC_API.HANDLE_EXCEPTIONS
287: (l_api_name,
288: G_PKG_NAME,
289: 'OKC_API.G_RET_STS_ERROR',

Line 286: x_return_status := OKC_API.HANDLE_EXCEPTIONS

282: END IF;
283: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
284: EXCEPTION
285: WHEN OKC_API.G_EXCEPTION_ERROR THEN
286: x_return_status := OKC_API.HANDLE_EXCEPTIONS
287: (l_api_name,
288: G_PKG_NAME,
289: 'OKC_API.G_RET_STS_ERROR',
290: x_msg_count,

Line 289: 'OKC_API.G_RET_STS_ERROR',

285: WHEN OKC_API.G_EXCEPTION_ERROR THEN
286: x_return_status := OKC_API.HANDLE_EXCEPTIONS
287: (l_api_name,
288: G_PKG_NAME,
289: 'OKC_API.G_RET_STS_ERROR',
290: x_msg_count,
291: x_msg_data,
292: '_PUB');
293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

289: 'OKC_API.G_RET_STS_ERROR',
290: x_msg_count,
291: x_msg_data,
292: '_PUB');
293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
294: x_return_status := OKC_API.HANDLE_EXCEPTIONS
295: (l_api_name,
296: G_PKG_NAME,
297: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 294: x_return_status := OKC_API.HANDLE_EXCEPTIONS

290: x_msg_count,
291: x_msg_data,
292: '_PUB');
293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
294: x_return_status := OKC_API.HANDLE_EXCEPTIONS
295: (l_api_name,
296: G_PKG_NAME,
297: 'OKC_API.G_RET_STS_UNEXP_ERROR',
298: x_msg_count,

Line 297: 'OKC_API.G_RET_STS_UNEXP_ERROR',

293: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
294: x_return_status := OKC_API.HANDLE_EXCEPTIONS
295: (l_api_name,
296: G_PKG_NAME,
297: 'OKC_API.G_RET_STS_UNEXP_ERROR',
298: x_msg_count,
299: x_msg_data,
300: '_PUB');
301: WHEN OTHERS THEN

Line 302: x_return_status := OKC_API.HANDLE_EXCEPTIONS

298: x_msg_count,
299: x_msg_data,
300: '_PUB');
301: WHEN OTHERS THEN
302: x_return_status := OKC_API.HANDLE_EXCEPTIONS
303: (l_api_name,
304: G_PKG_NAME,
305: 'OTHERS',
306: x_msg_count,

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

316: x_msg_data OUT NOCOPY VARCHAR2,
317: p_talv_tbl IN talv_tbl_type,
318: x_talv_tbl OUT NOCOPY talv_tbl_type) IS
319: i NUMBER := 0;
320: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
321: BEGIN
322: x_return_status := OKC_API.G_RET_STS_SUCCESS;
323: IF p_talv_tbl.COUNT > 0 THEN
324: i := p_talv_tbl.FIRST;

Line 322: x_return_status := OKC_API.G_RET_STS_SUCCESS;

318: x_talv_tbl OUT NOCOPY talv_tbl_type) IS
319: i NUMBER := 0;
320: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
321: BEGIN
322: x_return_status := OKC_API.G_RET_STS_SUCCESS;
323: IF p_talv_tbl.COUNT > 0 THEN
324: i := p_talv_tbl.FIRST;
325: LOOP
326: UPDATE_TPA_RELTV(

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

330: x_msg_count,
331: x_msg_data,
332: p_talv_tbl(i),
333: x_talv_tbl(i));
334: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
335: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
336: x_return_status := l_return_status;
337: raise G_EXCEPTION_HALT_VALIDATION;
338: ELSE

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

331: x_msg_data,
332: p_talv_tbl(i),
333: x_talv_tbl(i));
334: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
335: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
336: x_return_status := l_return_status;
337: raise G_EXCEPTION_HALT_VALIDATION;
338: ELSE
339: x_return_status := l_return_status;

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

346: EXCEPTION
347: WHEN G_EXCEPTION_HALT_VALIDATION THEN
348: NULL;
349: WHEN OTHERS THEN
350: OKC_API.set_message(p_app_name => g_app_name,
351: p_msg_name => g_unexpected_error,
352: p_token1 => g_sqlcode_token,
353: p_token1_value => sqlcode,
354: p_token2 => g_sqlerrm_token,

Line 356: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

352: p_token1 => g_sqlcode_token,
353: p_token1_value => sqlcode,
354: p_token2 => g_sqlerrm_token,
355: p_token2_value => sqlerrm);
356: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
357: END UPDATE_TPA_RELTV;
358:
359: PROCEDURE DELETE_TPA_RELTV(
360: p_api_version IN NUMBER,

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

366: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_TPA_RELTV';
367: l_return_status VARCHAR2(1);
368: l_talv_rec talv_rec_type := p_talv_rec;
369: BEGIN
370: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
371: p_init_msg_list,
372: '_PUB',
373: x_return_status);
374: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

370: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
371: p_init_msg_list,
372: '_PUB',
373: x_return_status);
374: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;

Line 375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

371: p_init_msg_list,
372: '_PUB',
373: x_return_status);
374: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;
379: -- Call user hook for BEFORE

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

372: '_PUB',
373: x_return_status);
374: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;
379: -- Call user hook for BEFORE
380: g_talv_rec := l_talv_rec;

Line 377: raise OKC_API.G_EXCEPTION_ERROR;

373: x_return_status);
374: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
375: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
376: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
377: raise OKC_API.G_EXCEPTION_ERROR;
378: END IF;
379: -- Call user hook for BEFORE
380: g_talv_rec := l_talv_rec;
381: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

378: END IF;
379: -- Call user hook for BEFORE
380: g_talv_rec := l_talv_rec;
381: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
382: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
383: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
384: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
385: raise OKC_API.G_EXCEPTION_ERROR;
386: END IF;

Line 383: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

379: -- Call user hook for BEFORE
380: g_talv_rec := l_talv_rec;
381: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
382: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
383: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
384: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
385: raise OKC_API.G_EXCEPTION_ERROR;
386: END IF;
387: OKC_TIME_PVT.DELETE_TPA_RELTV(

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

380: g_talv_rec := l_talv_rec;
381: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
382: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
383: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
384: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
385: raise OKC_API.G_EXCEPTION_ERROR;
386: END IF;
387: OKC_TIME_PVT.DELETE_TPA_RELTV(
388: p_api_version,

Line 385: raise OKC_API.G_EXCEPTION_ERROR;

381: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
382: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
383: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
384: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
385: raise OKC_API.G_EXCEPTION_ERROR;
386: END IF;
387: OKC_TIME_PVT.DELETE_TPA_RELTV(
388: p_api_version,
389: p_init_msg_list,

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

390: x_return_status,
391: x_msg_count,
392: x_msg_data,
393: p_talv_rec);
394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
397: raise OKC_API.G_EXCEPTION_ERROR;
398: END IF;

Line 395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

391: x_msg_count,
392: x_msg_data,
393: p_talv_rec);
394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
397: raise OKC_API.G_EXCEPTION_ERROR;
398: END IF;
399:

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

392: x_msg_data,
393: p_talv_rec);
394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
397: raise OKC_API.G_EXCEPTION_ERROR;
398: END IF;
399:
400: -- Call user hook for AFTER

Line 397: raise OKC_API.G_EXCEPTION_ERROR;

393: p_talv_rec);
394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
397: raise OKC_API.G_EXCEPTION_ERROR;
398: END IF;
399:
400: -- Call user hook for AFTER
401: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');

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

398: END IF;
399:
400: -- Call user hook for AFTER
401: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
402: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: raise OKC_API.G_EXCEPTION_ERROR;
406: END IF;

Line 403: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

399:
400: -- Call user hook for AFTER
401: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
402: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: raise OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

400: -- Call user hook for AFTER
401: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
402: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: raise OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
408: EXCEPTION

Line 405: raise OKC_API.G_EXCEPTION_ERROR;

401: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
402: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
403: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: raise OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
408: EXCEPTION
409: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

403: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
404: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
405: raise OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
408: EXCEPTION
409: WHEN OKC_API.G_EXCEPTION_ERROR THEN
410: x_return_status := OKC_API.HANDLE_EXCEPTIONS
411: (l_api_name,

Line 409: WHEN OKC_API.G_EXCEPTION_ERROR THEN

405: raise OKC_API.G_EXCEPTION_ERROR;
406: END IF;
407: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
408: EXCEPTION
409: WHEN OKC_API.G_EXCEPTION_ERROR THEN
410: x_return_status := OKC_API.HANDLE_EXCEPTIONS
411: (l_api_name,
412: G_PKG_NAME,
413: 'OKC_API.G_RET_STS_ERROR',

Line 410: x_return_status := OKC_API.HANDLE_EXCEPTIONS

406: END IF;
407: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
408: EXCEPTION
409: WHEN OKC_API.G_EXCEPTION_ERROR THEN
410: x_return_status := OKC_API.HANDLE_EXCEPTIONS
411: (l_api_name,
412: G_PKG_NAME,
413: 'OKC_API.G_RET_STS_ERROR',
414: x_msg_count,

Line 413: 'OKC_API.G_RET_STS_ERROR',

409: WHEN OKC_API.G_EXCEPTION_ERROR THEN
410: x_return_status := OKC_API.HANDLE_EXCEPTIONS
411: (l_api_name,
412: G_PKG_NAME,
413: 'OKC_API.G_RET_STS_ERROR',
414: x_msg_count,
415: x_msg_data,
416: '_PUB');
417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

413: 'OKC_API.G_RET_STS_ERROR',
414: x_msg_count,
415: x_msg_data,
416: '_PUB');
417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
418: x_return_status := OKC_API.HANDLE_EXCEPTIONS
419: (l_api_name,
420: G_PKG_NAME,
421: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 418: x_return_status := OKC_API.HANDLE_EXCEPTIONS

414: x_msg_count,
415: x_msg_data,
416: '_PUB');
417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
418: x_return_status := OKC_API.HANDLE_EXCEPTIONS
419: (l_api_name,
420: G_PKG_NAME,
421: 'OKC_API.G_RET_STS_UNEXP_ERROR',
422: x_msg_count,

Line 421: 'OKC_API.G_RET_STS_UNEXP_ERROR',

417: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
418: x_return_status := OKC_API.HANDLE_EXCEPTIONS
419: (l_api_name,
420: G_PKG_NAME,
421: 'OKC_API.G_RET_STS_UNEXP_ERROR',
422: x_msg_count,
423: x_msg_data,
424: '_PUB');
425: WHEN OTHERS THEN

Line 426: x_return_status := OKC_API.HANDLE_EXCEPTIONS

422: x_msg_count,
423: x_msg_data,
424: '_PUB');
425: WHEN OTHERS THEN
426: x_return_status := OKC_API.HANDLE_EXCEPTIONS
427: (l_api_name,
428: G_PKG_NAME,
429: 'OTHERS',
430: x_msg_count,

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

439: x_msg_count OUT NOCOPY NUMBER,
440: x_msg_data OUT NOCOPY VARCHAR2,
441: p_talv_tbl IN talv_tbl_type) IS
442: i NUMBER := 0;
443: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
444: BEGIN
445: x_return_status := OKC_API.G_RET_STS_SUCCESS;
446: IF p_talv_tbl.COUNT > 0 THEN
447: i := p_talv_tbl.FIRST;

Line 445: x_return_status := OKC_API.G_RET_STS_SUCCESS;

441: p_talv_tbl IN talv_tbl_type) IS
442: i NUMBER := 0;
443: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
444: BEGIN
445: x_return_status := OKC_API.G_RET_STS_SUCCESS;
446: IF p_talv_tbl.COUNT > 0 THEN
447: i := p_talv_tbl.FIRST;
448: LOOP
449: DELETE_TPA_RELTV(

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

452: l_return_status,
453: x_msg_count,
454: x_msg_data,
455: p_talv_tbl(i));
456: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
457: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
458: x_return_status := l_return_status;
459: raise G_EXCEPTION_HALT_VALIDATION;
460: ELSE

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

453: x_msg_count,
454: x_msg_data,
455: p_talv_tbl(i));
456: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
457: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
458: x_return_status := l_return_status;
459: raise G_EXCEPTION_HALT_VALIDATION;
460: ELSE
461: x_return_status := l_return_status;

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

468: EXCEPTION
469: WHEN G_EXCEPTION_HALT_VALIDATION THEN
470: NULL;
471: WHEN OTHERS THEN
472: OKC_API.set_message(p_app_name => g_app_name,
473: p_msg_name => g_unexpected_error,
474: p_token1 => g_sqlcode_token,
475: p_token1_value => sqlcode,
476: p_token2 => g_sqlerrm_token,

Line 478: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

474: p_token1 => g_sqlcode_token,
475: p_token1_value => sqlcode,
476: p_token2 => g_sqlerrm_token,
477: p_token2_value => sqlerrm);
478: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
479: END DELETE_TPA_RELTV;
480:
481: PROCEDURE LOCK_TPA_RELTV(
482: p_api_version IN NUMBER,

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

502: x_msg_count OUT NOCOPY NUMBER,
503: x_msg_data OUT NOCOPY VARCHAR2,
504: p_talv_tbl IN talv_tbl_type) IS
505: i NUMBER := 0;
506: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
507: BEGIN
508: x_return_status := OKC_API.G_RET_STS_SUCCESS;
509: IF p_talv_tbl.COUNT > 0 THEN
510: i := p_talv_tbl.FIRST;

Line 508: x_return_status := OKC_API.G_RET_STS_SUCCESS;

504: p_talv_tbl IN talv_tbl_type) IS
505: i NUMBER := 0;
506: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
507: BEGIN
508: x_return_status := OKC_API.G_RET_STS_SUCCESS;
509: IF p_talv_tbl.COUNT > 0 THEN
510: i := p_talv_tbl.FIRST;
511: LOOP
512: LOCK_TPA_RELTV(

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

515: l_return_status,
516: x_msg_count,
517: x_msg_data,
518: p_talv_tbl(i));
519: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
520: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
521: x_return_status := l_return_status;
522: raise G_EXCEPTION_HALT_VALIDATION;
523: ELSE

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

516: x_msg_count,
517: x_msg_data,
518: p_talv_tbl(i));
519: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
520: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
521: x_return_status := l_return_status;
522: raise G_EXCEPTION_HALT_VALIDATION;
523: ELSE
524: x_return_status := l_return_status;

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

531: EXCEPTION
532: WHEN G_EXCEPTION_HALT_VALIDATION THEN
533: NULL;
534: WHEN OTHERS THEN
535: OKC_API.set_message(p_app_name => g_app_name,
536: p_msg_name => g_unexpected_error,
537: p_token1 => g_sqlcode_token,
538: p_token1_value => sqlcode,
539: p_token2 => g_sqlerrm_token,

Line 541: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

537: p_token1 => g_sqlcode_token,
538: p_token1_value => sqlcode,
539: p_token2 => g_sqlerrm_token,
540: p_token2_value => sqlerrm);
541: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
542: END LOCK_TPA_RELTV;
543:
544: PROCEDURE VALID_TPA_RELTV(
545: p_api_version IN NUMBER,

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

565: x_msg_count OUT NOCOPY NUMBER,
566: x_msg_data OUT NOCOPY VARCHAR2,
567: p_talv_tbl IN talv_tbl_type) IS
568: i NUMBER := 0;
569: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
570: BEGIN
571: x_return_status := OKC_API.G_RET_STS_SUCCESS;
572: IF p_talv_tbl.COUNT > 0 THEN
573: i := p_talv_tbl.FIRST;

Line 571: x_return_status := OKC_API.G_RET_STS_SUCCESS;

567: p_talv_tbl IN talv_tbl_type) IS
568: i NUMBER := 0;
569: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
570: BEGIN
571: x_return_status := OKC_API.G_RET_STS_SUCCESS;
572: IF p_talv_tbl.COUNT > 0 THEN
573: i := p_talv_tbl.FIRST;
574: LOOP
575: VALID_TPA_RELTV(

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

578: l_return_status,
579: x_msg_count,
580: x_msg_data,
581: p_talv_tbl(i));
582: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
583: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
584: x_return_status := l_return_status;
585: raise G_EXCEPTION_HALT_VALIDATION;
586: ELSE

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

579: x_msg_count,
580: x_msg_data,
581: p_talv_tbl(i));
582: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
583: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
584: x_return_status := l_return_status;
585: raise G_EXCEPTION_HALT_VALIDATION;
586: ELSE
587: x_return_status := l_return_status;

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

594: EXCEPTION
595: WHEN G_EXCEPTION_HALT_VALIDATION THEN
596: NULL;
597: WHEN OTHERS THEN
598: OKC_API.set_message(p_app_name => g_app_name,
599: p_msg_name => g_unexpected_error,
600: p_token1 => g_sqlcode_token,
601: p_token1_value => sqlcode,
602: p_token2 => g_sqlerrm_token,

Line 604: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

600: p_token1 => g_sqlcode_token,
601: p_token1_value => sqlcode,
602: p_token2 => g_sqlerrm_token,
603: p_token2_value => sqlerrm);
604: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
605: END VALID_TPA_RELTV;
606:
607: FUNCTION migrate_talv(p_talv_evt_rec1 IN talv_evt_rec_type,
608: p_talv_evt_rec2 IN talv_evt_rec_type)

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

686: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_TPA_RELTV';
687: l_return_status VARCHAR2(1);
688: l_talv_evt_rec talv_evt_rec_type := p_talv_evt_rec;
689: BEGIN
690: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
691: p_init_msg_list,
692: '_PUB',
693: x_return_status);
694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

690: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
691: p_init_msg_list,
692: '_PUB',
693: x_return_status);
694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: raise OKC_API.G_EXCEPTION_ERROR;
698: END IF;

Line 695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

691: p_init_msg_list,
692: '_PUB',
693: x_return_status);
694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: raise OKC_API.G_EXCEPTION_ERROR;
698: END IF;
699: -- Call user hook for BEFORE

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

692: '_PUB',
693: x_return_status);
694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: raise OKC_API.G_EXCEPTION_ERROR;
698: END IF;
699: -- Call user hook for BEFORE
700: g_talv_evt_rec := l_talv_evt_rec;

Line 697: raise OKC_API.G_EXCEPTION_ERROR;

693: x_return_status);
694: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: raise OKC_API.G_EXCEPTION_ERROR;
698: END IF;
699: -- Call user hook for BEFORE
700: g_talv_evt_rec := l_talv_evt_rec;
701: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

698: END IF;
699: -- Call user hook for BEFORE
700: g_talv_evt_rec := l_talv_evt_rec;
701: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
702: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: raise OKC_API.G_EXCEPTION_ERROR;
706: END IF;

Line 703: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

699: -- Call user hook for BEFORE
700: g_talv_evt_rec := l_talv_evt_rec;
701: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
702: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: raise OKC_API.G_EXCEPTION_ERROR;
706: END IF;
707: l_talv_evt_rec := migrate_talv(l_talv_evt_rec, g_talv_evt_rec);

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

700: g_talv_evt_rec := l_talv_evt_rec;
701: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
702: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: raise OKC_API.G_EXCEPTION_ERROR;
706: END IF;
707: l_talv_evt_rec := migrate_talv(l_talv_evt_rec, g_talv_evt_rec);
708: OKC_TIME_PVT.CREATE_TPA_RELTV(

Line 705: raise OKC_API.G_EXCEPTION_ERROR;

701: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
702: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
703: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
704: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
705: raise OKC_API.G_EXCEPTION_ERROR;
706: END IF;
707: l_talv_evt_rec := migrate_talv(l_talv_evt_rec, g_talv_evt_rec);
708: OKC_TIME_PVT.CREATE_TPA_RELTV(
709: p_api_version,

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

712: x_msg_count,
713: x_msg_data,
714: p_talv_evt_rec,
715: x_talv_evt_rec);
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;

Line 717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

713: x_msg_data,
714: p_talv_evt_rec,
715: x_talv_evt_rec);
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721:

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

714: p_talv_evt_rec,
715: x_talv_evt_rec);
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721:
722: -- Call user hook for AFTER

Line 719: raise OKC_API.G_EXCEPTION_ERROR;

715: x_talv_evt_rec);
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721:
722: -- Call user hook for AFTER
723: g_talv_evt_rec := x_talv_evt_rec;

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

721:
722: -- Call user hook for AFTER
723: g_talv_evt_rec := x_talv_evt_rec;
724: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
725: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
726: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
727: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
728: raise OKC_API.G_EXCEPTION_ERROR;
729: END IF;

Line 726: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

722: -- Call user hook for AFTER
723: g_talv_evt_rec := x_talv_evt_rec;
724: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
725: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
726: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
727: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
728: raise OKC_API.G_EXCEPTION_ERROR;
729: END IF;
730: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

723: g_talv_evt_rec := x_talv_evt_rec;
724: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
725: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
726: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
727: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
728: raise OKC_API.G_EXCEPTION_ERROR;
729: END IF;
730: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
731: EXCEPTION

Line 728: raise OKC_API.G_EXCEPTION_ERROR;

724: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
725: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
726: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
727: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
728: raise OKC_API.G_EXCEPTION_ERROR;
729: END IF;
730: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
731: EXCEPTION
732: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

726: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
727: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
728: raise OKC_API.G_EXCEPTION_ERROR;
729: END IF;
730: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
731: EXCEPTION
732: WHEN OKC_API.G_EXCEPTION_ERROR THEN
733: x_return_status := OKC_API.HANDLE_EXCEPTIONS
734: (l_api_name,

Line 732: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

Line 733: x_return_status := OKC_API.HANDLE_EXCEPTIONS

729: END IF;
730: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
731: EXCEPTION
732: WHEN OKC_API.G_EXCEPTION_ERROR THEN
733: x_return_status := OKC_API.HANDLE_EXCEPTIONS
734: (l_api_name,
735: G_PKG_NAME,
736: 'OKC_API.G_RET_STS_ERROR',
737: x_msg_count,

Line 736: 'OKC_API.G_RET_STS_ERROR',

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

Line 740: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 741: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 744: 'OKC_API.G_RET_STS_UNEXP_ERROR',

740: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
741: x_return_status := OKC_API.HANDLE_EXCEPTIONS
742: (l_api_name,
743: G_PKG_NAME,
744: 'OKC_API.G_RET_STS_UNEXP_ERROR',
745: x_msg_count,
746: x_msg_data,
747: '_PUB');
748: WHEN OTHERS THEN

Line 749: x_return_status := OKC_API.HANDLE_EXCEPTIONS

745: x_msg_count,
746: x_msg_data,
747: '_PUB');
748: WHEN OTHERS THEN
749: x_return_status := OKC_API.HANDLE_EXCEPTIONS
750: (l_api_name,
751: G_PKG_NAME,
752: 'OTHERS',
753: x_msg_count,

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

763: x_msg_data OUT NOCOPY VARCHAR2,
764: p_talv_evt_tbl IN talv_evt_tbl_type,
765: x_talv_evt_tbl OUT NOCOPY talv_evt_tbl_type) IS
766: i NUMBER := 0;
767: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
768: BEGIN
769: x_return_status := OKC_API.G_RET_STS_SUCCESS;
770: IF p_talv_evt_tbl.COUNT > 0 THEN
771: i := p_talv_evt_tbl.FIRST;

Line 769: x_return_status := OKC_API.G_RET_STS_SUCCESS;

765: x_talv_evt_tbl OUT NOCOPY talv_evt_tbl_type) IS
766: i NUMBER := 0;
767: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
768: BEGIN
769: x_return_status := OKC_API.G_RET_STS_SUCCESS;
770: IF p_talv_evt_tbl.COUNT > 0 THEN
771: i := p_talv_evt_tbl.FIRST;
772: LOOP
773: CREATE_TPA_RELTV(

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

777: x_msg_count,
778: x_msg_data,
779: p_talv_evt_tbl(i),
780: x_talv_evt_tbl(i));
781: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
782: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
783: x_return_status := l_return_status;
784: raise G_EXCEPTION_HALT_VALIDATION;
785: ELSE

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

778: x_msg_data,
779: p_talv_evt_tbl(i),
780: x_talv_evt_tbl(i));
781: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
782: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
783: x_return_status := l_return_status;
784: raise G_EXCEPTION_HALT_VALIDATION;
785: ELSE
786: x_return_status := l_return_status;

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

793: EXCEPTION
794: WHEN G_EXCEPTION_HALT_VALIDATION THEN
795: NULL;
796: WHEN OTHERS THEN
797: OKC_API.set_message(p_app_name => g_app_name,
798: p_msg_name => g_unexpected_error,
799: p_token1 => g_sqlcode_token,
800: p_token1_value => sqlcode,
801: p_token2 => g_sqlerrm_token,

Line 803: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

799: p_token1 => g_sqlcode_token,
800: p_token1_value => sqlcode,
801: p_token2 => g_sqlerrm_token,
802: p_token2_value => sqlerrm);
803: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
804: END CREATE_TPA_RELTV;
805:
806: PROCEDURE UPDATE_TPA_RELTV(
807: p_api_version IN NUMBER,

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

814: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_TPA_RELTV';
815: l_return_status VARCHAR2(1);
816: l_talv_evt_rec talv_evt_rec_type := p_talv_evt_rec;
817: BEGIN
818: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
819: p_init_msg_list,
820: '_PUB',
821: x_return_status);
822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

818: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
819: p_init_msg_list,
820: '_PUB',
821: x_return_status);
822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
825: raise OKC_API.G_EXCEPTION_ERROR;
826: END IF;

Line 823: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

819: p_init_msg_list,
820: '_PUB',
821: x_return_status);
822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
825: raise OKC_API.G_EXCEPTION_ERROR;
826: END IF;
827: -- Call user hook for BEFORE

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

820: '_PUB',
821: x_return_status);
822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
825: raise OKC_API.G_EXCEPTION_ERROR;
826: END IF;
827: -- Call user hook for BEFORE
828: g_talv_evt_rec := l_talv_evt_rec;

Line 825: raise OKC_API.G_EXCEPTION_ERROR;

821: x_return_status);
822: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
824: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
825: raise OKC_API.G_EXCEPTION_ERROR;
826: END IF;
827: -- Call user hook for BEFORE
828: g_talv_evt_rec := l_talv_evt_rec;
829: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

826: END IF;
827: -- Call user hook for BEFORE
828: g_talv_evt_rec := l_talv_evt_rec;
829: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
830: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
832: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
833: raise OKC_API.G_EXCEPTION_ERROR;
834: END IF;

Line 831: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

827: -- Call user hook for BEFORE
828: g_talv_evt_rec := l_talv_evt_rec;
829: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
830: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
832: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
833: raise OKC_API.G_EXCEPTION_ERROR;
834: END IF;
835: l_talv_evt_rec := migrate_talv(l_talv_evt_rec, g_talv_evt_rec);

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

828: g_talv_evt_rec := l_talv_evt_rec;
829: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
830: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
832: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
833: raise OKC_API.G_EXCEPTION_ERROR;
834: END IF;
835: l_talv_evt_rec := migrate_talv(l_talv_evt_rec, g_talv_evt_rec);
836: OKC_TIME_PVT.UPDATE_TPA_RELTV(

Line 833: raise OKC_API.G_EXCEPTION_ERROR;

829: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
830: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
832: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
833: raise OKC_API.G_EXCEPTION_ERROR;
834: END IF;
835: l_talv_evt_rec := migrate_talv(l_talv_evt_rec, g_talv_evt_rec);
836: OKC_TIME_PVT.UPDATE_TPA_RELTV(
837: p_api_version,

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

840: x_msg_count,
841: x_msg_data,
842: p_talv_evt_rec,
843: x_talv_evt_rec);
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;

Line 845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

841: x_msg_data,
842: p_talv_evt_rec,
843: x_talv_evt_rec);
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;
849:

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

842: p_talv_evt_rec,
843: x_talv_evt_rec);
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;
849:
850: -- Call user hook for AFTER

Line 847: raise OKC_API.G_EXCEPTION_ERROR;

843: x_talv_evt_rec);
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;
849:
850: -- Call user hook for AFTER
851: g_talv_evt_rec := x_talv_evt_rec;

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

849:
850: -- Call user hook for AFTER
851: g_talv_evt_rec := x_talv_evt_rec;
852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;

Line 854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

850: -- Call user hook for AFTER
851: g_talv_evt_rec := x_talv_evt_rec;
852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

851: g_talv_evt_rec := x_talv_evt_rec;
852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION

Line 856: raise OKC_API.G_EXCEPTION_ERROR;

852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,

Line 860: WHEN OKC_API.G_EXCEPTION_ERROR THEN

856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,
863: G_PKG_NAME,
864: 'OKC_API.G_RET_STS_ERROR',

Line 861: x_return_status := OKC_API.HANDLE_EXCEPTIONS

857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,
863: G_PKG_NAME,
864: 'OKC_API.G_RET_STS_ERROR',
865: x_msg_count,

Line 864: 'OKC_API.G_RET_STS_ERROR',

860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,
863: G_PKG_NAME,
864: 'OKC_API.G_RET_STS_ERROR',
865: x_msg_count,
866: x_msg_data,
867: '_PUB');
868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

864: 'OKC_API.G_RET_STS_ERROR',
865: x_msg_count,
866: x_msg_data,
867: '_PUB');
868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
870: (l_api_name,
871: G_PKG_NAME,
872: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 869: x_return_status := OKC_API.HANDLE_EXCEPTIONS

865: x_msg_count,
866: x_msg_data,
867: '_PUB');
868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
870: (l_api_name,
871: G_PKG_NAME,
872: 'OKC_API.G_RET_STS_UNEXP_ERROR',
873: x_msg_count,

Line 872: 'OKC_API.G_RET_STS_UNEXP_ERROR',

868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
870: (l_api_name,
871: G_PKG_NAME,
872: 'OKC_API.G_RET_STS_UNEXP_ERROR',
873: x_msg_count,
874: x_msg_data,
875: '_PUB');
876: WHEN OTHERS THEN

Line 877: x_return_status := OKC_API.HANDLE_EXCEPTIONS

873: x_msg_count,
874: x_msg_data,
875: '_PUB');
876: WHEN OTHERS THEN
877: x_return_status := OKC_API.HANDLE_EXCEPTIONS
878: (l_api_name,
879: G_PKG_NAME,
880: 'OTHERS',
881: x_msg_count,

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

891: x_msg_data OUT NOCOPY VARCHAR2,
892: p_talv_evt_tbl IN talv_evt_tbl_type,
893: x_talv_evt_tbl OUT NOCOPY talv_evt_tbl_type) IS
894: i NUMBER := 0;
895: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
896: BEGIN
897: x_return_status := OKC_API.G_RET_STS_SUCCESS;
898: IF p_talv_evt_tbl.COUNT > 0 THEN
899: i := p_talv_evt_tbl.FIRST;

Line 897: x_return_status := OKC_API.G_RET_STS_SUCCESS;

893: x_talv_evt_tbl OUT NOCOPY talv_evt_tbl_type) IS
894: i NUMBER := 0;
895: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
896: BEGIN
897: x_return_status := OKC_API.G_RET_STS_SUCCESS;
898: IF p_talv_evt_tbl.COUNT > 0 THEN
899: i := p_talv_evt_tbl.FIRST;
900: LOOP
901: UPDATE_TPA_RELTV(

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

905: x_msg_count,
906: x_msg_data,
907: p_talv_evt_tbl(i),
908: x_talv_evt_tbl(i));
909: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
910: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
911: x_return_status := l_return_status;
912: raise G_EXCEPTION_HALT_VALIDATION;
913: ELSE

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

906: x_msg_data,
907: p_talv_evt_tbl(i),
908: x_talv_evt_tbl(i));
909: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
910: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
911: x_return_status := l_return_status;
912: raise G_EXCEPTION_HALT_VALIDATION;
913: ELSE
914: x_return_status := l_return_status;

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

921: EXCEPTION
922: WHEN G_EXCEPTION_HALT_VALIDATION THEN
923: NULL;
924: WHEN OTHERS THEN
925: OKC_API.set_message(p_app_name => g_app_name,
926: p_msg_name => g_unexpected_error,
927: p_token1 => g_sqlcode_token,
928: p_token1_value => sqlcode,
929: p_token2 => g_sqlerrm_token,

Line 931: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

927: p_token1 => g_sqlcode_token,
928: p_token1_value => sqlcode,
929: p_token2 => g_sqlerrm_token,
930: p_token2_value => sqlerrm);
931: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
932: END UPDATE_TPA_RELTV;
933:
934: PROCEDURE DELETE_TPA_RELTV(
935: p_api_version IN NUMBER,

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

941: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_TPA_RELTV';
942: l_return_status VARCHAR2(1);
943: l_talv_evt_rec talv_evt_rec_type := p_talv_evt_rec;
944: BEGIN
945: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
946: p_init_msg_list,
947: '_PUB',
948: x_return_status);
949: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

945: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
946: p_init_msg_list,
947: '_PUB',
948: x_return_status);
949: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
950: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
951: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
952: raise OKC_API.G_EXCEPTION_ERROR;
953: END IF;

Line 950: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

946: p_init_msg_list,
947: '_PUB',
948: x_return_status);
949: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
950: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
951: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
952: raise OKC_API.G_EXCEPTION_ERROR;
953: END IF;
954: -- Call user hook for BEFORE

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

947: '_PUB',
948: x_return_status);
949: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
950: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
951: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
952: raise OKC_API.G_EXCEPTION_ERROR;
953: END IF;
954: -- Call user hook for BEFORE
955: g_talv_evt_rec := l_talv_evt_rec;

Line 952: raise OKC_API.G_EXCEPTION_ERROR;

948: x_return_status);
949: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
950: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
951: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
952: raise OKC_API.G_EXCEPTION_ERROR;
953: END IF;
954: -- Call user hook for BEFORE
955: g_talv_evt_rec := l_talv_evt_rec;
956: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

953: END IF;
954: -- Call user hook for BEFORE
955: g_talv_evt_rec := l_talv_evt_rec;
956: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_ERROR;
961: END IF;

Line 958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

954: -- Call user hook for BEFORE
955: g_talv_evt_rec := l_talv_evt_rec;
956: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_ERROR;
961: END IF;
962: OKC_TIME_PVT.DELETE_TPA_RELTV(

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

955: g_talv_evt_rec := l_talv_evt_rec;
956: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_ERROR;
961: END IF;
962: OKC_TIME_PVT.DELETE_TPA_RELTV(
963: p_api_version,

Line 960: raise OKC_API.G_EXCEPTION_ERROR;

956: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
957: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
958: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
959: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
960: raise OKC_API.G_EXCEPTION_ERROR;
961: END IF;
962: OKC_TIME_PVT.DELETE_TPA_RELTV(
963: p_api_version,
964: p_init_msg_list,

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

965: x_return_status,
966: x_msg_count,
967: x_msg_data,
968: p_talv_evt_rec);
969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
972: raise OKC_API.G_EXCEPTION_ERROR;
973: END IF;

Line 970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

966: x_msg_count,
967: x_msg_data,
968: p_talv_evt_rec);
969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
972: raise OKC_API.G_EXCEPTION_ERROR;
973: END IF;
974:

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

967: x_msg_data,
968: p_talv_evt_rec);
969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
972: raise OKC_API.G_EXCEPTION_ERROR;
973: END IF;
974:
975: -- Call user hook for AFTER

Line 972: raise OKC_API.G_EXCEPTION_ERROR;

968: p_talv_evt_rec);
969: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
970: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
971: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
972: raise OKC_API.G_EXCEPTION_ERROR;
973: END IF;
974:
975: -- Call user hook for AFTER
976: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');

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

973: END IF;
974:
975: -- Call user hook for AFTER
976: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
977: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
978: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
979: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
980: raise OKC_API.G_EXCEPTION_ERROR;
981: END IF;

Line 978: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

974:
975: -- Call user hook for AFTER
976: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
977: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
978: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
979: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
980: raise OKC_API.G_EXCEPTION_ERROR;
981: END IF;
982: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

975: -- Call user hook for AFTER
976: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
977: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
978: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
979: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
980: raise OKC_API.G_EXCEPTION_ERROR;
981: END IF;
982: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
983: EXCEPTION

Line 980: raise OKC_API.G_EXCEPTION_ERROR;

976: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
977: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
978: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
979: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
980: raise OKC_API.G_EXCEPTION_ERROR;
981: END IF;
982: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
983: EXCEPTION
984: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

978: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
979: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
980: raise OKC_API.G_EXCEPTION_ERROR;
981: END IF;
982: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
983: EXCEPTION
984: WHEN OKC_API.G_EXCEPTION_ERROR THEN
985: x_return_status := OKC_API.HANDLE_EXCEPTIONS
986: (l_api_name,

Line 984: WHEN OKC_API.G_EXCEPTION_ERROR THEN

980: raise OKC_API.G_EXCEPTION_ERROR;
981: END IF;
982: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
983: EXCEPTION
984: WHEN OKC_API.G_EXCEPTION_ERROR THEN
985: x_return_status := OKC_API.HANDLE_EXCEPTIONS
986: (l_api_name,
987: G_PKG_NAME,
988: 'OKC_API.G_RET_STS_ERROR',

Line 985: x_return_status := OKC_API.HANDLE_EXCEPTIONS

981: END IF;
982: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
983: EXCEPTION
984: WHEN OKC_API.G_EXCEPTION_ERROR THEN
985: x_return_status := OKC_API.HANDLE_EXCEPTIONS
986: (l_api_name,
987: G_PKG_NAME,
988: 'OKC_API.G_RET_STS_ERROR',
989: x_msg_count,

Line 988: 'OKC_API.G_RET_STS_ERROR',

984: WHEN OKC_API.G_EXCEPTION_ERROR THEN
985: x_return_status := OKC_API.HANDLE_EXCEPTIONS
986: (l_api_name,
987: G_PKG_NAME,
988: 'OKC_API.G_RET_STS_ERROR',
989: x_msg_count,
990: x_msg_data,
991: '_PUB');
992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

988: 'OKC_API.G_RET_STS_ERROR',
989: x_msg_count,
990: x_msg_data,
991: '_PUB');
992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
993: x_return_status := OKC_API.HANDLE_EXCEPTIONS
994: (l_api_name,
995: G_PKG_NAME,
996: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 993: x_return_status := OKC_API.HANDLE_EXCEPTIONS

989: x_msg_count,
990: x_msg_data,
991: '_PUB');
992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
993: x_return_status := OKC_API.HANDLE_EXCEPTIONS
994: (l_api_name,
995: G_PKG_NAME,
996: 'OKC_API.G_RET_STS_UNEXP_ERROR',
997: x_msg_count,

Line 996: 'OKC_API.G_RET_STS_UNEXP_ERROR',

992: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
993: x_return_status := OKC_API.HANDLE_EXCEPTIONS
994: (l_api_name,
995: G_PKG_NAME,
996: 'OKC_API.G_RET_STS_UNEXP_ERROR',
997: x_msg_count,
998: x_msg_data,
999: '_PUB');
1000: WHEN OTHERS THEN

Line 1001: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

1014: x_msg_count OUT NOCOPY NUMBER,
1015: x_msg_data OUT NOCOPY VARCHAR2,
1016: p_talv_evt_tbl IN talv_evt_tbl_type) IS
1017: i NUMBER := 0;
1018: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1019: BEGIN
1020: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1021: IF p_talv_evt_tbl.COUNT > 0 THEN
1022: i := p_talv_evt_tbl.FIRST;

Line 1020: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1016: p_talv_evt_tbl IN talv_evt_tbl_type) IS
1017: i NUMBER := 0;
1018: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1019: BEGIN
1020: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1021: IF p_talv_evt_tbl.COUNT > 0 THEN
1022: i := p_talv_evt_tbl.FIRST;
1023: LOOP
1024: DELETE_TPA_RELTV(

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

1027: l_return_status,
1028: x_msg_count,
1029: x_msg_data,
1030: p_talv_evt_tbl(i));
1031: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1032: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1033: x_return_status := l_return_status;
1034: raise G_EXCEPTION_HALT_VALIDATION;
1035: ELSE

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

1028: x_msg_count,
1029: x_msg_data,
1030: p_talv_evt_tbl(i));
1031: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1032: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1033: x_return_status := l_return_status;
1034: raise G_EXCEPTION_HALT_VALIDATION;
1035: ELSE
1036: x_return_status := l_return_status;

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

1043: EXCEPTION
1044: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1045: NULL;
1046: WHEN OTHERS THEN
1047: OKC_API.set_message(p_app_name => g_app_name,
1048: p_msg_name => g_unexpected_error,
1049: p_token1 => g_sqlcode_token,
1050: p_token1_value => sqlcode,
1051: p_token2 => g_sqlerrm_token,

Line 1053: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1049: p_token1 => g_sqlcode_token,
1050: p_token1_value => sqlcode,
1051: p_token2 => g_sqlerrm_token,
1052: p_token2_value => sqlerrm);
1053: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1054: END DELETE_TPA_RELTV;
1055:
1056: PROCEDURE LOCK_TPA_RELTV(
1057: p_api_version IN NUMBER,

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

1077: x_msg_count OUT NOCOPY NUMBER,
1078: x_msg_data OUT NOCOPY VARCHAR2,
1079: p_talv_evt_tbl IN talv_evt_tbl_type) IS
1080: i NUMBER := 0;
1081: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1082: BEGIN
1083: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1084: IF p_talv_evt_tbl.COUNT > 0 THEN
1085: i := p_talv_evt_tbl.FIRST;

Line 1083: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1079: p_talv_evt_tbl IN talv_evt_tbl_type) IS
1080: i NUMBER := 0;
1081: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1082: BEGIN
1083: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1084: IF p_talv_evt_tbl.COUNT > 0 THEN
1085: i := p_talv_evt_tbl.FIRST;
1086: LOOP
1087: LOCK_TPA_RELTV(

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

1090: l_return_status,
1091: x_msg_count,
1092: x_msg_data,
1093: p_talv_evt_tbl(i));
1094: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1095: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1096: x_return_status := l_return_status;
1097: raise G_EXCEPTION_HALT_VALIDATION;
1098: ELSE

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

1091: x_msg_count,
1092: x_msg_data,
1093: p_talv_evt_tbl(i));
1094: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1095: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1096: x_return_status := l_return_status;
1097: raise G_EXCEPTION_HALT_VALIDATION;
1098: ELSE
1099: x_return_status := l_return_status;

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

1106: EXCEPTION
1107: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1108: NULL;
1109: WHEN OTHERS THEN
1110: OKC_API.set_message(p_app_name => g_app_name,
1111: p_msg_name => g_unexpected_error,
1112: p_token1 => g_sqlcode_token,
1113: p_token1_value => sqlcode,
1114: p_token2 => g_sqlerrm_token,

Line 1116: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1112: p_token1 => g_sqlcode_token,
1113: p_token1_value => sqlcode,
1114: p_token2 => g_sqlerrm_token,
1115: p_token2_value => sqlerrm);
1116: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1117: END LOCK_TPA_RELTV;
1118:
1119: PROCEDURE VALID_TPA_RELTV(
1120: p_api_version IN NUMBER,

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

1140: x_msg_count OUT NOCOPY NUMBER,
1141: x_msg_data OUT NOCOPY VARCHAR2,
1142: p_talv_evt_tbl IN talv_evt_tbl_type) IS
1143: i NUMBER := 0;
1144: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1145: BEGIN
1146: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1147: IF p_talv_evt_tbl.COUNT > 0 THEN
1148: i := p_talv_evt_tbl.FIRST;

Line 1146: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1142: p_talv_evt_tbl IN talv_evt_tbl_type) IS
1143: i NUMBER := 0;
1144: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1145: BEGIN
1146: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1147: IF p_talv_evt_tbl.COUNT > 0 THEN
1148: i := p_talv_evt_tbl.FIRST;
1149: LOOP
1150: VALID_TPA_RELTV(

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

1153: l_return_status,
1154: x_msg_count,
1155: x_msg_data,
1156: p_talv_evt_tbl(i));
1157: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1158: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1159: x_return_status := l_return_status;
1160: raise G_EXCEPTION_HALT_VALIDATION;
1161: ELSE

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

1154: x_msg_count,
1155: x_msg_data,
1156: p_talv_evt_tbl(i));
1157: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1158: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1159: x_return_status := l_return_status;
1160: raise G_EXCEPTION_HALT_VALIDATION;
1161: ELSE
1162: x_return_status := l_return_status;

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

1169: EXCEPTION
1170: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1171: NULL;
1172: WHEN OTHERS THEN
1173: OKC_API.set_message(p_app_name => g_app_name,
1174: p_msg_name => g_unexpected_error,
1175: p_token1 => g_sqlcode_token,
1176: p_token1_value => sqlcode,
1177: p_token2 => g_sqlerrm_token,

Line 1179: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1175: p_token1 => g_sqlcode_token,
1176: p_token1_value => sqlcode,
1177: p_token2 => g_sqlerrm_token,
1178: p_token2_value => sqlerrm);
1179: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1180: END VALID_TPA_RELTV;
1181:
1182: --------------------------------------------------------------------------
1183: ---The following procedures cater to handling of OKC_TIME_TPA_VALUE

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

1261: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_TPA_VALUE';
1262: l_return_status VARCHAR2(1);
1263: l_tavv_rec tavv_rec_type := p_tavv_rec;
1264: BEGIN
1265: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1266: p_init_msg_list,
1267: '_PUB',
1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1265: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1266: p_init_msg_list,
1267: '_PUB',
1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: raise OKC_API.G_EXCEPTION_ERROR;
1273: END IF;

Line 1270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1266: p_init_msg_list,
1267: '_PUB',
1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: raise OKC_API.G_EXCEPTION_ERROR;
1273: END IF;
1274: -- Call user hook for BEFORE

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

1267: '_PUB',
1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: raise OKC_API.G_EXCEPTION_ERROR;
1273: END IF;
1274: -- Call user hook for BEFORE
1275: g_tavv_rec := l_tavv_rec;

Line 1272: raise OKC_API.G_EXCEPTION_ERROR;

1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: raise OKC_API.G_EXCEPTION_ERROR;
1273: END IF;
1274: -- Call user hook for BEFORE
1275: g_tavv_rec := l_tavv_rec;
1276: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1273: END IF;
1274: -- Call user hook for BEFORE
1275: g_tavv_rec := l_tavv_rec;
1276: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1277: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1278: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1279: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_ERROR;
1281: END IF;

Line 1278: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1274: -- Call user hook for BEFORE
1275: g_tavv_rec := l_tavv_rec;
1276: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1277: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1278: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1279: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_ERROR;
1281: END IF;
1282: l_tavv_rec := migrate_tavv(l_tavv_rec, g_tavv_rec);

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

1275: g_tavv_rec := l_tavv_rec;
1276: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1277: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1278: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1279: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_ERROR;
1281: END IF;
1282: l_tavv_rec := migrate_tavv(l_tavv_rec, g_tavv_rec);
1283: OKC_TIME_PVT.CREATE_TPA_VALUE(

Line 1280: raise OKC_API.G_EXCEPTION_ERROR;

1276: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1277: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1278: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1279: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1280: raise OKC_API.G_EXCEPTION_ERROR;
1281: END IF;
1282: l_tavv_rec := migrate_tavv(l_tavv_rec, g_tavv_rec);
1283: OKC_TIME_PVT.CREATE_TPA_VALUE(
1284: p_api_version,

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

1287: x_msg_count,
1288: x_msg_data,
1289: p_tavv_rec,
1290: x_tavv_rec);
1291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1294: raise OKC_API.G_EXCEPTION_ERROR;
1295: END IF;

Line 1292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1288: x_msg_data,
1289: p_tavv_rec,
1290: x_tavv_rec);
1291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1294: raise OKC_API.G_EXCEPTION_ERROR;
1295: END IF;
1296:

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

1289: p_tavv_rec,
1290: x_tavv_rec);
1291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1294: raise OKC_API.G_EXCEPTION_ERROR;
1295: END IF;
1296:
1297: -- Call user hook for AFTER

Line 1294: raise OKC_API.G_EXCEPTION_ERROR;

1290: x_tavv_rec);
1291: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1292: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1293: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1294: raise OKC_API.G_EXCEPTION_ERROR;
1295: END IF;
1296:
1297: -- Call user hook for AFTER
1298: g_tavv_rec := x_tavv_rec;

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

1296:
1297: -- Call user hook for AFTER
1298: g_tavv_rec := x_tavv_rec;
1299: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1300: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1301: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1302: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1303: raise OKC_API.G_EXCEPTION_ERROR;
1304: END IF;

Line 1301: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1297: -- Call user hook for AFTER
1298: g_tavv_rec := x_tavv_rec;
1299: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1300: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1301: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1302: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1303: raise OKC_API.G_EXCEPTION_ERROR;
1304: END IF;
1305: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1298: g_tavv_rec := x_tavv_rec;
1299: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1300: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1301: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1302: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1303: raise OKC_API.G_EXCEPTION_ERROR;
1304: END IF;
1305: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1306: EXCEPTION

Line 1303: raise OKC_API.G_EXCEPTION_ERROR;

1299: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1300: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1301: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1302: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1303: raise OKC_API.G_EXCEPTION_ERROR;
1304: END IF;
1305: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1306: EXCEPTION
1307: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1301: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1302: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1303: raise OKC_API.G_EXCEPTION_ERROR;
1304: END IF;
1305: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1306: EXCEPTION
1307: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1308: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1309: (l_api_name,

Line 1307: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1303: raise OKC_API.G_EXCEPTION_ERROR;
1304: END IF;
1305: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1306: EXCEPTION
1307: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1308: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1309: (l_api_name,
1310: G_PKG_NAME,
1311: 'OKC_API.G_RET_STS_ERROR',

Line 1308: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1304: END IF;
1305: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1306: EXCEPTION
1307: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1308: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1309: (l_api_name,
1310: G_PKG_NAME,
1311: 'OKC_API.G_RET_STS_ERROR',
1312: x_msg_count,

Line 1311: 'OKC_API.G_RET_STS_ERROR',

1307: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1308: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1309: (l_api_name,
1310: G_PKG_NAME,
1311: 'OKC_API.G_RET_STS_ERROR',
1312: x_msg_count,
1313: x_msg_data,
1314: '_PUB');
1315: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1315: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1311: 'OKC_API.G_RET_STS_ERROR',
1312: x_msg_count,
1313: x_msg_data,
1314: '_PUB');
1315: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1317: (l_api_name,
1318: G_PKG_NAME,
1319: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1312: x_msg_count,
1313: x_msg_data,
1314: '_PUB');
1315: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1317: (l_api_name,
1318: G_PKG_NAME,
1319: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1320: x_msg_count,

Line 1319: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1315: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1316: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1317: (l_api_name,
1318: G_PKG_NAME,
1319: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1320: x_msg_count,
1321: x_msg_data,
1322: '_PUB');
1323: WHEN OTHERS THEN

Line 1324: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

1338: x_msg_data OUT NOCOPY VARCHAR2,
1339: p_tavv_tbl IN tavv_tbl_type,
1340: x_tavv_tbl OUT NOCOPY tavv_tbl_type) IS
1341: i NUMBER := 0;
1342: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1343: BEGIN
1344: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1345: IF p_tavv_tbl.COUNT > 0 THEN
1346: i := p_tavv_tbl.FIRST;

Line 1344: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1340: x_tavv_tbl OUT NOCOPY tavv_tbl_type) IS
1341: i NUMBER := 0;
1342: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1343: BEGIN
1344: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1345: IF p_tavv_tbl.COUNT > 0 THEN
1346: i := p_tavv_tbl.FIRST;
1347: LOOP
1348: CREATE_TPA_VALUE(

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

1352: x_msg_count,
1353: x_msg_data,
1354: p_tavv_tbl(i),
1355: x_tavv_tbl(i));
1356: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1357: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1358: x_return_status := l_return_status;
1359: raise G_EXCEPTION_HALT_VALIDATION;
1360: ELSE

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

1353: x_msg_data,
1354: p_tavv_tbl(i),
1355: x_tavv_tbl(i));
1356: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1357: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1358: x_return_status := l_return_status;
1359: raise G_EXCEPTION_HALT_VALIDATION;
1360: ELSE
1361: x_return_status := l_return_status;

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

1368: EXCEPTION
1369: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1370: NULL;
1371: WHEN OTHERS THEN
1372: OKC_API.set_message(p_app_name => g_app_name,
1373: p_msg_name => g_unexpected_error,
1374: p_token1 => g_sqlcode_token,
1375: p_token1_value => sqlcode,
1376: p_token2 => g_sqlerrm_token,

Line 1378: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1374: p_token1 => g_sqlcode_token,
1375: p_token1_value => sqlcode,
1376: p_token2 => g_sqlerrm_token,
1377: p_token2_value => sqlerrm);
1378: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1379: END CREATE_TPA_VALUE;
1380:
1381: PROCEDURE UPDATE_TPA_VALUE(
1382: p_api_version IN NUMBER,

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

1389: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_TPA_VALUE';
1390: l_return_status VARCHAR2(1);
1391: l_tavv_rec tavv_rec_type := p_tavv_rec;
1392: BEGIN
1393: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1394: p_init_msg_list,
1395: '_PUB',
1396: x_return_status);
1397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1393: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1394: p_init_msg_list,
1395: '_PUB',
1396: x_return_status);
1397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1398: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1399: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1400: raise OKC_API.G_EXCEPTION_ERROR;
1401: END IF;

Line 1398: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1394: p_init_msg_list,
1395: '_PUB',
1396: x_return_status);
1397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1398: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1399: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1400: raise OKC_API.G_EXCEPTION_ERROR;
1401: END IF;
1402: -- Call user hook for BEFORE

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

1395: '_PUB',
1396: x_return_status);
1397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1398: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1399: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1400: raise OKC_API.G_EXCEPTION_ERROR;
1401: END IF;
1402: -- Call user hook for BEFORE
1403: g_tavv_rec := l_tavv_rec;

Line 1400: raise OKC_API.G_EXCEPTION_ERROR;

1396: x_return_status);
1397: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1398: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1399: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1400: raise OKC_API.G_EXCEPTION_ERROR;
1401: END IF;
1402: -- Call user hook for BEFORE
1403: g_tavv_rec := l_tavv_rec;
1404: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1401: END IF;
1402: -- Call user hook for BEFORE
1403: g_tavv_rec := l_tavv_rec;
1404: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1405: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1407: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1408: raise OKC_API.G_EXCEPTION_ERROR;
1409: END IF;

Line 1406: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1402: -- Call user hook for BEFORE
1403: g_tavv_rec := l_tavv_rec;
1404: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1405: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1407: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1408: raise OKC_API.G_EXCEPTION_ERROR;
1409: END IF;
1410: l_tavv_rec := migrate_tavv(l_tavv_rec, g_tavv_rec);

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

1403: g_tavv_rec := l_tavv_rec;
1404: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1405: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1407: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1408: raise OKC_API.G_EXCEPTION_ERROR;
1409: END IF;
1410: l_tavv_rec := migrate_tavv(l_tavv_rec, g_tavv_rec);
1411: OKC_TIME_PVT.UPDATE_TPA_VALUE(

Line 1408: raise OKC_API.G_EXCEPTION_ERROR;

1404: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1405: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1407: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1408: raise OKC_API.G_EXCEPTION_ERROR;
1409: END IF;
1410: l_tavv_rec := migrate_tavv(l_tavv_rec, g_tavv_rec);
1411: OKC_TIME_PVT.UPDATE_TPA_VALUE(
1412: p_api_version,

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

1415: x_msg_count,
1416: x_msg_data,
1417: p_tavv_rec,
1418: x_tavv_rec);
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;

Line 1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1416: x_msg_data,
1417: p_tavv_rec,
1418: x_tavv_rec);
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424:

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

1417: p_tavv_rec,
1418: x_tavv_rec);
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424:
1425: -- Call user hook for AFTER

Line 1422: raise OKC_API.G_EXCEPTION_ERROR;

1418: x_tavv_rec);
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424:
1425: -- Call user hook for AFTER
1426: g_tavv_rec := x_tavv_rec;

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

1424:
1425: -- Call user hook for AFTER
1426: g_tavv_rec := x_tavv_rec;
1427: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1428: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1429: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1430: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1431: raise OKC_API.G_EXCEPTION_ERROR;
1432: END IF;

Line 1429: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1425: -- Call user hook for AFTER
1426: g_tavv_rec := x_tavv_rec;
1427: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1428: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1429: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1430: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1431: raise OKC_API.G_EXCEPTION_ERROR;
1432: END IF;
1433: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1426: g_tavv_rec := x_tavv_rec;
1427: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1428: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1429: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1430: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1431: raise OKC_API.G_EXCEPTION_ERROR;
1432: END IF;
1433: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1434: EXCEPTION

Line 1431: raise OKC_API.G_EXCEPTION_ERROR;

1427: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1428: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1429: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1430: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1431: raise OKC_API.G_EXCEPTION_ERROR;
1432: END IF;
1433: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1434: EXCEPTION
1435: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1429: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1430: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1431: raise OKC_API.G_EXCEPTION_ERROR;
1432: END IF;
1433: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1434: EXCEPTION
1435: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1436: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1437: (l_api_name,

Line 1435: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1431: raise OKC_API.G_EXCEPTION_ERROR;
1432: END IF;
1433: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1434: EXCEPTION
1435: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1436: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1437: (l_api_name,
1438: G_PKG_NAME,
1439: 'OKC_API.G_RET_STS_ERROR',

Line 1436: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1432: END IF;
1433: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1434: EXCEPTION
1435: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1436: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1437: (l_api_name,
1438: G_PKG_NAME,
1439: 'OKC_API.G_RET_STS_ERROR',
1440: x_msg_count,

Line 1439: 'OKC_API.G_RET_STS_ERROR',

1435: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1436: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1437: (l_api_name,
1438: G_PKG_NAME,
1439: 'OKC_API.G_RET_STS_ERROR',
1440: x_msg_count,
1441: x_msg_data,
1442: '_PUB');
1443: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1443: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1439: 'OKC_API.G_RET_STS_ERROR',
1440: x_msg_count,
1441: x_msg_data,
1442: '_PUB');
1443: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1444: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1445: (l_api_name,
1446: G_PKG_NAME,
1447: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1444: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1440: x_msg_count,
1441: x_msg_data,
1442: '_PUB');
1443: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1444: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1445: (l_api_name,
1446: G_PKG_NAME,
1447: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1448: x_msg_count,

Line 1447: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1443: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1444: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1445: (l_api_name,
1446: G_PKG_NAME,
1447: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1448: x_msg_count,
1449: x_msg_data,
1450: '_PUB');
1451: WHEN OTHERS THEN

Line 1452: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1448: x_msg_count,
1449: x_msg_data,
1450: '_PUB');
1451: WHEN OTHERS THEN
1452: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1453: (l_api_name,
1454: G_PKG_NAME,
1455: 'OTHERS',
1456: x_msg_count,

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

1466: x_msg_data OUT NOCOPY VARCHAR2,
1467: p_tavv_tbl IN tavv_tbl_type,
1468: x_tavv_tbl OUT NOCOPY tavv_tbl_type) IS
1469: i NUMBER := 0;
1470: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1471: BEGIN
1472: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1473: IF p_tavv_tbl.COUNT > 0 THEN
1474: i := p_tavv_tbl.FIRST;

Line 1472: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1468: x_tavv_tbl OUT NOCOPY tavv_tbl_type) IS
1469: i NUMBER := 0;
1470: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1471: BEGIN
1472: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1473: IF p_tavv_tbl.COUNT > 0 THEN
1474: i := p_tavv_tbl.FIRST;
1475: LOOP
1476: UPDATE_TPA_VALUE(

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

1480: x_msg_count,
1481: x_msg_data,
1482: p_tavv_tbl(i),
1483: x_tavv_tbl(i));
1484: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1485: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1486: x_return_status := l_return_status;
1487: raise G_EXCEPTION_HALT_VALIDATION;
1488: ELSE

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

1481: x_msg_data,
1482: p_tavv_tbl(i),
1483: x_tavv_tbl(i));
1484: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1485: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1486: x_return_status := l_return_status;
1487: raise G_EXCEPTION_HALT_VALIDATION;
1488: ELSE
1489: x_return_status := l_return_status;

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

1496: EXCEPTION
1497: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1498: NULL;
1499: WHEN OTHERS THEN
1500: OKC_API.set_message(p_app_name => g_app_name,
1501: p_msg_name => g_unexpected_error,
1502: p_token1 => g_sqlcode_token,
1503: p_token1_value => sqlcode,
1504: p_token2 => g_sqlerrm_token,

Line 1506: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1502: p_token1 => g_sqlcode_token,
1503: p_token1_value => sqlcode,
1504: p_token2 => g_sqlerrm_token,
1505: p_token2_value => sqlerrm);
1506: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1507: END UPDATE_TPA_VALUE;
1508:
1509: PROCEDURE DELETE_TPA_VALUE(
1510: p_api_version IN NUMBER,

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

1516: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_TPA_VALUE';
1517: l_return_status VARCHAR2(1);
1518: l_tavv_rec tavv_rec_type := p_tavv_rec;
1519: BEGIN
1520: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1521: p_init_msg_list,
1522: '_PUB',
1523: x_return_status);
1524: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1520: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1521: p_init_msg_list,
1522: '_PUB',
1523: x_return_status);
1524: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1525: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1526: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1527: raise OKC_API.G_EXCEPTION_ERROR;
1528: END IF;

Line 1525: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1521: p_init_msg_list,
1522: '_PUB',
1523: x_return_status);
1524: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1525: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1526: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1527: raise OKC_API.G_EXCEPTION_ERROR;
1528: END IF;
1529: -- Call user hook for BEFORE

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

1522: '_PUB',
1523: x_return_status);
1524: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1525: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1526: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1527: raise OKC_API.G_EXCEPTION_ERROR;
1528: END IF;
1529: -- Call user hook for BEFORE
1530: g_tavv_rec := l_tavv_rec;

Line 1527: raise OKC_API.G_EXCEPTION_ERROR;

1523: x_return_status);
1524: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1525: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1526: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1527: raise OKC_API.G_EXCEPTION_ERROR;
1528: END IF;
1529: -- Call user hook for BEFORE
1530: g_tavv_rec := l_tavv_rec;
1531: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1528: END IF;
1529: -- Call user hook for BEFORE
1530: g_tavv_rec := l_tavv_rec;
1531: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: raise OKC_API.G_EXCEPTION_ERROR;
1536: END IF;

Line 1533: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1529: -- Call user hook for BEFORE
1530: g_tavv_rec := l_tavv_rec;
1531: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: raise OKC_API.G_EXCEPTION_ERROR;
1536: END IF;
1537: OKC_TIME_PVT.DELETE_TPA_VALUE(

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

1530: g_tavv_rec := l_tavv_rec;
1531: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: raise OKC_API.G_EXCEPTION_ERROR;
1536: END IF;
1537: OKC_TIME_PVT.DELETE_TPA_VALUE(
1538: p_api_version,

Line 1535: raise OKC_API.G_EXCEPTION_ERROR;

1531: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1532: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1533: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1534: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1535: raise OKC_API.G_EXCEPTION_ERROR;
1536: END IF;
1537: OKC_TIME_PVT.DELETE_TPA_VALUE(
1538: p_api_version,
1539: p_init_msg_list,

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

1540: x_return_status,
1541: x_msg_count,
1542: x_msg_data,
1543: p_tavv_rec);
1544: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1545: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1546: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1547: raise OKC_API.G_EXCEPTION_ERROR;
1548: END IF;

Line 1545: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1541: x_msg_count,
1542: x_msg_data,
1543: p_tavv_rec);
1544: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1545: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1546: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1547: raise OKC_API.G_EXCEPTION_ERROR;
1548: END IF;
1549:

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

1542: x_msg_data,
1543: p_tavv_rec);
1544: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1545: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1546: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1547: raise OKC_API.G_EXCEPTION_ERROR;
1548: END IF;
1549:
1550: -- Call user hook for AFTER

Line 1547: raise OKC_API.G_EXCEPTION_ERROR;

1543: p_tavv_rec);
1544: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1545: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1546: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1547: raise OKC_API.G_EXCEPTION_ERROR;
1548: END IF;
1549:
1550: -- Call user hook for AFTER
1551: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');

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

1548: END IF;
1549:
1550: -- Call user hook for AFTER
1551: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1552: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1553: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1554: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1555: raise OKC_API.G_EXCEPTION_ERROR;
1556: END IF;

Line 1553: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1549:
1550: -- Call user hook for AFTER
1551: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1552: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1553: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1554: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1555: raise OKC_API.G_EXCEPTION_ERROR;
1556: END IF;
1557: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1550: -- Call user hook for AFTER
1551: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1552: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1553: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1554: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1555: raise OKC_API.G_EXCEPTION_ERROR;
1556: END IF;
1557: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1558: EXCEPTION

Line 1555: raise OKC_API.G_EXCEPTION_ERROR;

1551: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1552: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1553: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1554: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1555: raise OKC_API.G_EXCEPTION_ERROR;
1556: END IF;
1557: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1558: EXCEPTION
1559: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1553: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1554: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1555: raise OKC_API.G_EXCEPTION_ERROR;
1556: END IF;
1557: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1558: EXCEPTION
1559: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1560: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1561: (l_api_name,

Line 1559: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

Line 1560: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 1563: 'OKC_API.G_RET_STS_ERROR',

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

Line 1567: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 1568: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 1571: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1567: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1568: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1569: (l_api_name,
1570: G_PKG_NAME,
1571: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1572: x_msg_count,
1573: x_msg_data,
1574: '_PUB');
1575: WHEN OTHERS THEN

Line 1576: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1572: x_msg_count,
1573: x_msg_data,
1574: '_PUB');
1575: WHEN OTHERS THEN
1576: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1577: (l_api_name,
1578: G_PKG_NAME,
1579: 'OTHERS',
1580: x_msg_count,

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

1589: x_msg_count OUT NOCOPY NUMBER,
1590: x_msg_data OUT NOCOPY VARCHAR2,
1591: p_tavv_tbl IN tavv_tbl_type) IS
1592: i NUMBER := 0;
1593: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1594: BEGIN
1595: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1596: IF p_tavv_tbl.COUNT > 0 THEN
1597: i := p_tavv_tbl.FIRST;

Line 1595: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1591: p_tavv_tbl IN tavv_tbl_type) IS
1592: i NUMBER := 0;
1593: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1594: BEGIN
1595: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1596: IF p_tavv_tbl.COUNT > 0 THEN
1597: i := p_tavv_tbl.FIRST;
1598: LOOP
1599: DELETE_TPA_VALUE(

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

1602: l_return_status,
1603: x_msg_count,
1604: x_msg_data,
1605: p_tavv_tbl(i));
1606: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1607: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1608: x_return_status := l_return_status;
1609: raise G_EXCEPTION_HALT_VALIDATION;
1610: ELSE

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

1603: x_msg_count,
1604: x_msg_data,
1605: p_tavv_tbl(i));
1606: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1607: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1608: x_return_status := l_return_status;
1609: raise G_EXCEPTION_HALT_VALIDATION;
1610: ELSE
1611: x_return_status := l_return_status;

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

1618: EXCEPTION
1619: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1620: NULL;
1621: WHEN OTHERS THEN
1622: OKC_API.set_message(p_app_name => g_app_name,
1623: p_msg_name => g_unexpected_error,
1624: p_token1 => g_sqlcode_token,
1625: p_token1_value => sqlcode,
1626: p_token2 => g_sqlerrm_token,

Line 1628: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1624: p_token1 => g_sqlcode_token,
1625: p_token1_value => sqlcode,
1626: p_token2 => g_sqlerrm_token,
1627: p_token2_value => sqlerrm);
1628: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1629: END DELETE_TPA_VALUE;
1630:
1631: PROCEDURE LOCK_TPA_VALUE(
1632: p_api_version IN NUMBER,

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

1652: x_msg_count OUT NOCOPY NUMBER,
1653: x_msg_data OUT NOCOPY VARCHAR2,
1654: p_tavv_tbl IN tavv_tbl_type) IS
1655: i NUMBER := 0;
1656: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1657: BEGIN
1658: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1659: IF p_tavv_tbl.COUNT > 0 THEN
1660: i := p_tavv_tbl.FIRST;

Line 1658: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1654: p_tavv_tbl IN tavv_tbl_type) IS
1655: i NUMBER := 0;
1656: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1657: BEGIN
1658: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1659: IF p_tavv_tbl.COUNT > 0 THEN
1660: i := p_tavv_tbl.FIRST;
1661: LOOP
1662: LOCK_TPA_VALUE(

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

1665: l_return_status,
1666: x_msg_count,
1667: x_msg_data,
1668: p_tavv_tbl(i));
1669: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1670: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1671: x_return_status := l_return_status;
1672: raise G_EXCEPTION_HALT_VALIDATION;
1673: ELSE

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

1666: x_msg_count,
1667: x_msg_data,
1668: p_tavv_tbl(i));
1669: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1670: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1671: x_return_status := l_return_status;
1672: raise G_EXCEPTION_HALT_VALIDATION;
1673: ELSE
1674: x_return_status := l_return_status;

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

1681: EXCEPTION
1682: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1683: NULL;
1684: WHEN OTHERS THEN
1685: OKC_API.set_message(p_app_name => g_app_name,
1686: p_msg_name => g_unexpected_error,
1687: p_token1 => g_sqlcode_token,
1688: p_token1_value => sqlcode,
1689: p_token2 => g_sqlerrm_token,

Line 1691: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1687: p_token1 => g_sqlcode_token,
1688: p_token1_value => sqlcode,
1689: p_token2 => g_sqlerrm_token,
1690: p_token2_value => sqlerrm);
1691: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1692: END LOCK_TPA_VALUE;
1693:
1694: PROCEDURE VALID_TPA_VALUE(
1695: p_api_version IN NUMBER,

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

1715: x_msg_count OUT NOCOPY NUMBER,
1716: x_msg_data OUT NOCOPY VARCHAR2,
1717: p_tavv_tbl IN tavv_tbl_type) IS
1718: i NUMBER := 0;
1719: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1720: BEGIN
1721: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1722: IF p_tavv_tbl.COUNT > 0 THEN
1723: i := p_tavv_tbl.FIRST;

Line 1721: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1717: p_tavv_tbl IN tavv_tbl_type) IS
1718: i NUMBER := 0;
1719: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1720: BEGIN
1721: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1722: IF p_tavv_tbl.COUNT > 0 THEN
1723: i := p_tavv_tbl.FIRST;
1724: LOOP
1725: VALID_TPA_VALUE(

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

1728: l_return_status,
1729: x_msg_count,
1730: x_msg_data,
1731: p_tavv_tbl(i));
1732: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1733: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1734: x_return_status := l_return_status;
1735: raise G_EXCEPTION_HALT_VALIDATION;
1736: ELSE

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

1729: x_msg_count,
1730: x_msg_data,
1731: p_tavv_tbl(i));
1732: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1733: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1734: x_return_status := l_return_status;
1735: raise G_EXCEPTION_HALT_VALIDATION;
1736: ELSE
1737: x_return_status := l_return_status;

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

1744: EXCEPTION
1745: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1746: NULL;
1747: WHEN OTHERS THEN
1748: OKC_API.set_message(p_app_name => g_app_name,
1749: p_msg_name => g_unexpected_error,
1750: p_token1 => g_sqlcode_token,
1751: p_token1_value => sqlcode,
1752: p_token2 => g_sqlerrm_token,

Line 1754: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1750: p_token1 => g_sqlcode_token,
1751: p_token1_value => sqlcode,
1752: p_token2 => g_sqlerrm_token,
1753: p_token2_value => sqlerrm);
1754: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1755: END VALID_TPA_VALUE;
1756:
1757: --------------------------------------------------------------------------
1758: ---The following procedures cater to handling of OKC_TIME_TPG_DELIMITED

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

1842: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_TPG_DELIMITED';
1843: l_return_status VARCHAR2(1);
1844: l_tgdv_ext_rec tgdv_ext_rec_type := p_tgdv_ext_rec;
1845: BEGIN
1846: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1847: p_init_msg_list,
1848: '_PUB',
1849: x_return_status);
1850: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1846: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1847: p_init_msg_list,
1848: '_PUB',
1849: x_return_status);
1850: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1851: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1852: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1853: raise OKC_API.G_EXCEPTION_ERROR;
1854: END IF;

Line 1851: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1847: p_init_msg_list,
1848: '_PUB',
1849: x_return_status);
1850: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1851: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1852: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1853: raise OKC_API.G_EXCEPTION_ERROR;
1854: END IF;
1855: -- Call user hook for BEFORE

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

1848: '_PUB',
1849: x_return_status);
1850: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1851: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1852: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1853: raise OKC_API.G_EXCEPTION_ERROR;
1854: END IF;
1855: -- Call user hook for BEFORE
1856: g_tgdv_ext_rec := l_tgdv_ext_rec;

Line 1853: raise OKC_API.G_EXCEPTION_ERROR;

1849: x_return_status);
1850: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1851: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1852: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1853: raise OKC_API.G_EXCEPTION_ERROR;
1854: END IF;
1855: -- Call user hook for BEFORE
1856: g_tgdv_ext_rec := l_tgdv_ext_rec;
1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1854: END IF;
1855: -- Call user hook for BEFORE
1856: g_tgdv_ext_rec := l_tgdv_ext_rec;
1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;

Line 1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1855: -- Call user hook for BEFORE
1856: g_tgdv_ext_rec := l_tgdv_ext_rec;
1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;
1863: l_tgdv_ext_rec := migrate_tgdv(l_tgdv_ext_rec, g_tgdv_ext_rec);

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

1856: g_tgdv_ext_rec := l_tgdv_ext_rec;
1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;
1863: l_tgdv_ext_rec := migrate_tgdv(l_tgdv_ext_rec, g_tgdv_ext_rec);
1864: OKC_TIME_PVT.CREATE_TPG_DELIMITED(

Line 1861: raise OKC_API.G_EXCEPTION_ERROR;

1857: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1858: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1859: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1860: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1861: raise OKC_API.G_EXCEPTION_ERROR;
1862: END IF;
1863: l_tgdv_ext_rec := migrate_tgdv(l_tgdv_ext_rec, g_tgdv_ext_rec);
1864: OKC_TIME_PVT.CREATE_TPG_DELIMITED(
1865: p_api_version,

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

1868: x_msg_count,
1869: x_msg_data,
1870: p_tgdv_ext_rec,
1871: x_tgdv_ext_rec);
1872: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1873: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1874: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1875: raise OKC_API.G_EXCEPTION_ERROR;
1876: END IF;

Line 1873: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1869: x_msg_data,
1870: p_tgdv_ext_rec,
1871: x_tgdv_ext_rec);
1872: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1873: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1874: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1875: raise OKC_API.G_EXCEPTION_ERROR;
1876: END IF;
1877:

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

1870: p_tgdv_ext_rec,
1871: x_tgdv_ext_rec);
1872: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1873: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1874: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1875: raise OKC_API.G_EXCEPTION_ERROR;
1876: END IF;
1877:
1878: -- Call user hook for AFTER

Line 1875: raise OKC_API.G_EXCEPTION_ERROR;

1871: x_tgdv_ext_rec);
1872: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1873: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1874: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1875: raise OKC_API.G_EXCEPTION_ERROR;
1876: END IF;
1877:
1878: -- Call user hook for AFTER
1879: g_tgdv_ext_rec := x_tgdv_ext_rec;

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

1877:
1878: -- Call user hook for AFTER
1879: g_tgdv_ext_rec := x_tgdv_ext_rec;
1880: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1881: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1882: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1883: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1884: raise OKC_API.G_EXCEPTION_ERROR;
1885: END IF;

Line 1882: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1878: -- Call user hook for AFTER
1879: g_tgdv_ext_rec := x_tgdv_ext_rec;
1880: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1881: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1882: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1883: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1884: raise OKC_API.G_EXCEPTION_ERROR;
1885: END IF;
1886: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1879: g_tgdv_ext_rec := x_tgdv_ext_rec;
1880: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1881: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1882: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1883: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1884: raise OKC_API.G_EXCEPTION_ERROR;
1885: END IF;
1886: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1887: EXCEPTION

Line 1884: raise OKC_API.G_EXCEPTION_ERROR;

1880: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1881: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1882: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1883: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1884: raise OKC_API.G_EXCEPTION_ERROR;
1885: END IF;
1886: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1887: EXCEPTION
1888: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1882: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1883: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1884: raise OKC_API.G_EXCEPTION_ERROR;
1885: END IF;
1886: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1887: EXCEPTION
1888: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1889: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1890: (l_api_name,

Line 1888: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1884: raise OKC_API.G_EXCEPTION_ERROR;
1885: END IF;
1886: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1887: EXCEPTION
1888: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1889: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1890: (l_api_name,
1891: G_PKG_NAME,
1892: 'OKC_API.G_RET_STS_ERROR',

Line 1889: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1885: END IF;
1886: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1887: EXCEPTION
1888: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1889: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1890: (l_api_name,
1891: G_PKG_NAME,
1892: 'OKC_API.G_RET_STS_ERROR',
1893: x_msg_count,

Line 1892: 'OKC_API.G_RET_STS_ERROR',

1888: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1889: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1890: (l_api_name,
1891: G_PKG_NAME,
1892: 'OKC_API.G_RET_STS_ERROR',
1893: x_msg_count,
1894: x_msg_data,
1895: '_PUB');
1896: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1896: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1892: 'OKC_API.G_RET_STS_ERROR',
1893: x_msg_count,
1894: x_msg_data,
1895: '_PUB');
1896: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1897: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1898: (l_api_name,
1899: G_PKG_NAME,
1900: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1897: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1893: x_msg_count,
1894: x_msg_data,
1895: '_PUB');
1896: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1897: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1898: (l_api_name,
1899: G_PKG_NAME,
1900: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1901: x_msg_count,

Line 1900: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1896: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1897: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1898: (l_api_name,
1899: G_PKG_NAME,
1900: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1901: x_msg_count,
1902: x_msg_data,
1903: '_PUB');
1904: WHEN OTHERS THEN

Line 1905: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1901: x_msg_count,
1902: x_msg_data,
1903: '_PUB');
1904: WHEN OTHERS THEN
1905: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1906: (l_api_name,
1907: G_PKG_NAME,
1908: 'OTHERS',
1909: x_msg_count,

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

1919: x_msg_data OUT NOCOPY VARCHAR2,
1920: p_tgdv_ext_tbl IN tgdv_ext_tbl_type,
1921: x_tgdv_ext_tbl OUT NOCOPY tgdv_ext_tbl_type) IS
1922: i NUMBER := 0;
1923: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1924: BEGIN
1925: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1926: IF p_tgdv_ext_tbl.COUNT > 0 THEN
1927: i := p_tgdv_ext_tbl.FIRST;

Line 1925: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1921: x_tgdv_ext_tbl OUT NOCOPY tgdv_ext_tbl_type) IS
1922: i NUMBER := 0;
1923: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1924: BEGIN
1925: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1926: IF p_tgdv_ext_tbl.COUNT > 0 THEN
1927: i := p_tgdv_ext_tbl.FIRST;
1928: LOOP
1929: CREATE_TPG_DELIMITED(

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

1933: x_msg_count,
1934: x_msg_data,
1935: p_tgdv_ext_tbl(i),
1936: x_tgdv_ext_tbl(i));
1937: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1938: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1939: x_return_status := l_return_status;
1940: raise G_EXCEPTION_HALT_VALIDATION;
1941: ELSE

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

1934: x_msg_data,
1935: p_tgdv_ext_tbl(i),
1936: x_tgdv_ext_tbl(i));
1937: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1938: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1939: x_return_status := l_return_status;
1940: raise G_EXCEPTION_HALT_VALIDATION;
1941: ELSE
1942: x_return_status := l_return_status;

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

1949: EXCEPTION
1950: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1951: NULL;
1952: WHEN OTHERS THEN
1953: OKC_API.set_message(p_app_name => g_app_name,
1954: p_msg_name => g_unexpected_error,
1955: p_token1 => g_sqlcode_token,
1956: p_token1_value => sqlcode,
1957: p_token2 => g_sqlerrm_token,

Line 1959: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1955: p_token1 => g_sqlcode_token,
1956: p_token1_value => sqlcode,
1957: p_token2 => g_sqlerrm_token,
1958: p_token2_value => sqlerrm);
1959: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1960: END CREATE_TPG_DELIMITED;
1961:
1962: PROCEDURE UPDATE_TPG_DELIMITED(
1963: p_api_version IN NUMBER,

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

1970: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_TPG_DELIMITED';
1971: l_return_status VARCHAR2(1);
1972: l_tgdv_ext_rec tgdv_ext_rec_type := p_tgdv_ext_rec;
1973: BEGIN
1974: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1975: p_init_msg_list,
1976: '_PUB',
1977: x_return_status);
1978: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1974: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1975: p_init_msg_list,
1976: '_PUB',
1977: x_return_status);
1978: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1980: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1981: raise OKC_API.G_EXCEPTION_ERROR;
1982: END IF;

Line 1979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1975: p_init_msg_list,
1976: '_PUB',
1977: x_return_status);
1978: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1980: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1981: raise OKC_API.G_EXCEPTION_ERROR;
1982: END IF;
1983: -- Call user hook for BEFORE

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

1976: '_PUB',
1977: x_return_status);
1978: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1980: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1981: raise OKC_API.G_EXCEPTION_ERROR;
1982: END IF;
1983: -- Call user hook for BEFORE
1984: g_tgdv_ext_rec := l_tgdv_ext_rec;

Line 1981: raise OKC_API.G_EXCEPTION_ERROR;

1977: x_return_status);
1978: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1980: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1981: raise OKC_API.G_EXCEPTION_ERROR;
1982: END IF;
1983: -- Call user hook for BEFORE
1984: g_tgdv_ext_rec := l_tgdv_ext_rec;
1985: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1982: END IF;
1983: -- Call user hook for BEFORE
1984: g_tgdv_ext_rec := l_tgdv_ext_rec;
1985: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1986: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1987: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1988: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1989: raise OKC_API.G_EXCEPTION_ERROR;
1990: END IF;

Line 1987: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1983: -- Call user hook for BEFORE
1984: g_tgdv_ext_rec := l_tgdv_ext_rec;
1985: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1986: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1987: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1988: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1989: raise OKC_API.G_EXCEPTION_ERROR;
1990: END IF;
1991: l_tgdv_ext_rec := migrate_tgdv(l_tgdv_ext_rec, g_tgdv_ext_rec);

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

1984: g_tgdv_ext_rec := l_tgdv_ext_rec;
1985: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1986: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1987: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1988: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1989: raise OKC_API.G_EXCEPTION_ERROR;
1990: END IF;
1991: l_tgdv_ext_rec := migrate_tgdv(l_tgdv_ext_rec, g_tgdv_ext_rec);
1992: OKC_TIME_PVT.UPDATE_TPG_DELIMITED(

Line 1989: raise OKC_API.G_EXCEPTION_ERROR;

1985: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1986: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1987: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1988: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1989: raise OKC_API.G_EXCEPTION_ERROR;
1990: END IF;
1991: l_tgdv_ext_rec := migrate_tgdv(l_tgdv_ext_rec, g_tgdv_ext_rec);
1992: OKC_TIME_PVT.UPDATE_TPG_DELIMITED(
1993: p_api_version,

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

1996: x_msg_count,
1997: x_msg_data,
1998: p_tgdv_ext_rec,
1999: x_tgdv_ext_rec);
2000: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: raise OKC_API.G_EXCEPTION_ERROR;
2004: END IF;

Line 2001: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1997: x_msg_data,
1998: p_tgdv_ext_rec,
1999: x_tgdv_ext_rec);
2000: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: raise OKC_API.G_EXCEPTION_ERROR;
2004: END IF;
2005:

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

1998: p_tgdv_ext_rec,
1999: x_tgdv_ext_rec);
2000: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: raise OKC_API.G_EXCEPTION_ERROR;
2004: END IF;
2005:
2006: -- Call user hook for AFTER

Line 2003: raise OKC_API.G_EXCEPTION_ERROR;

1999: x_tgdv_ext_rec);
2000: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2001: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2002: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2003: raise OKC_API.G_EXCEPTION_ERROR;
2004: END IF;
2005:
2006: -- Call user hook for AFTER
2007: g_tgdv_ext_rec := x_tgdv_ext_rec;

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

2005:
2006: -- Call user hook for AFTER
2007: g_tgdv_ext_rec := x_tgdv_ext_rec;
2008: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2009: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: raise OKC_API.G_EXCEPTION_ERROR;
2013: END IF;

Line 2010: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2006: -- Call user hook for AFTER
2007: g_tgdv_ext_rec := x_tgdv_ext_rec;
2008: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2009: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: raise OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2007: g_tgdv_ext_rec := x_tgdv_ext_rec;
2008: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2009: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: raise OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2015: EXCEPTION

Line 2012: raise OKC_API.G_EXCEPTION_ERROR;

2008: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2009: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2010: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: raise OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2015: EXCEPTION
2016: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2010: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2011: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2012: raise OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2015: EXCEPTION
2016: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2017: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2018: (l_api_name,

Line 2016: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2012: raise OKC_API.G_EXCEPTION_ERROR;
2013: END IF;
2014: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2015: EXCEPTION
2016: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2017: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2018: (l_api_name,
2019: G_PKG_NAME,
2020: 'OKC_API.G_RET_STS_ERROR',

Line 2017: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2013: END IF;
2014: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2015: EXCEPTION
2016: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2017: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2018: (l_api_name,
2019: G_PKG_NAME,
2020: 'OKC_API.G_RET_STS_ERROR',
2021: x_msg_count,

Line 2020: 'OKC_API.G_RET_STS_ERROR',

2016: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2017: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2018: (l_api_name,
2019: G_PKG_NAME,
2020: 'OKC_API.G_RET_STS_ERROR',
2021: x_msg_count,
2022: x_msg_data,
2023: '_PUB');
2024: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2024: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2020: 'OKC_API.G_RET_STS_ERROR',
2021: x_msg_count,
2022: x_msg_data,
2023: '_PUB');
2024: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2025: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2026: (l_api_name,
2027: G_PKG_NAME,
2028: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2025: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2021: x_msg_count,
2022: x_msg_data,
2023: '_PUB');
2024: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2025: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2026: (l_api_name,
2027: G_PKG_NAME,
2028: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2029: x_msg_count,

Line 2028: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2024: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2025: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2026: (l_api_name,
2027: G_PKG_NAME,
2028: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2029: x_msg_count,
2030: x_msg_data,
2031: '_PUB');
2032: WHEN OTHERS THEN

Line 2033: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2029: x_msg_count,
2030: x_msg_data,
2031: '_PUB');
2032: WHEN OTHERS THEN
2033: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2034: (l_api_name,
2035: G_PKG_NAME,
2036: 'OTHERS',
2037: x_msg_count,

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

2047: x_msg_data OUT NOCOPY VARCHAR2,
2048: p_tgdv_ext_tbl IN tgdv_ext_tbl_type,
2049: x_tgdv_ext_tbl OUT NOCOPY tgdv_ext_tbl_type) IS
2050: i NUMBER := 0;
2051: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2052: BEGIN
2053: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2054: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2055: i := p_tgdv_ext_tbl.FIRST;

Line 2053: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2049: x_tgdv_ext_tbl OUT NOCOPY tgdv_ext_tbl_type) IS
2050: i NUMBER := 0;
2051: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2052: BEGIN
2053: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2054: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2055: i := p_tgdv_ext_tbl.FIRST;
2056: LOOP
2057: UPDATE_TPG_DELIMITED(

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

2061: x_msg_count,
2062: x_msg_data,
2063: p_tgdv_ext_tbl(i),
2064: x_tgdv_ext_tbl(i));
2065: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2067: x_return_status := l_return_status;
2068: raise G_EXCEPTION_HALT_VALIDATION;
2069: ELSE

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

2062: x_msg_data,
2063: p_tgdv_ext_tbl(i),
2064: x_tgdv_ext_tbl(i));
2065: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2067: x_return_status := l_return_status;
2068: raise G_EXCEPTION_HALT_VALIDATION;
2069: ELSE
2070: x_return_status := l_return_status;

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

2077: EXCEPTION
2078: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2079: NULL;
2080: WHEN OTHERS THEN
2081: OKC_API.set_message(p_app_name => g_app_name,
2082: p_msg_name => g_unexpected_error,
2083: p_token1 => g_sqlcode_token,
2084: p_token1_value => sqlcode,
2085: p_token2 => g_sqlerrm_token,

Line 2087: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2083: p_token1 => g_sqlcode_token,
2084: p_token1_value => sqlcode,
2085: p_token2 => g_sqlerrm_token,
2086: p_token2_value => sqlerrm);
2087: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2088: END UPDATE_TPG_DELIMITED;
2089:
2090: PROCEDURE DELETE_TPG_DELIMITED(
2091: p_api_version IN NUMBER,

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

2097: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_TPG_DELIMITED';
2098: l_return_status VARCHAR2(1);
2099: l_tgdv_ext_rec tgdv_ext_rec_type := p_tgdv_ext_rec;
2100: BEGIN
2101: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2102: p_init_msg_list,
2103: '_PUB',
2104: x_return_status);
2105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2101: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2102: p_init_msg_list,
2103: '_PUB',
2104: x_return_status);
2105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2108: raise OKC_API.G_EXCEPTION_ERROR;
2109: END IF;

Line 2106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2102: p_init_msg_list,
2103: '_PUB',
2104: x_return_status);
2105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2108: raise OKC_API.G_EXCEPTION_ERROR;
2109: END IF;
2110: -- Call user hook for BEFORE

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

2103: '_PUB',
2104: x_return_status);
2105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2108: raise OKC_API.G_EXCEPTION_ERROR;
2109: END IF;
2110: -- Call user hook for BEFORE
2111: g_tgdv_ext_rec := l_tgdv_ext_rec;

Line 2108: raise OKC_API.G_EXCEPTION_ERROR;

2104: x_return_status);
2105: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2106: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2107: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2108: raise OKC_API.G_EXCEPTION_ERROR;
2109: END IF;
2110: -- Call user hook for BEFORE
2111: g_tgdv_ext_rec := l_tgdv_ext_rec;
2112: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

2109: END IF;
2110: -- Call user hook for BEFORE
2111: g_tgdv_ext_rec := l_tgdv_ext_rec;
2112: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2113: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2114: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2115: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2116: raise OKC_API.G_EXCEPTION_ERROR;
2117: END IF;

Line 2114: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2110: -- Call user hook for BEFORE
2111: g_tgdv_ext_rec := l_tgdv_ext_rec;
2112: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2113: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2114: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2115: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2116: raise OKC_API.G_EXCEPTION_ERROR;
2117: END IF;
2118: OKC_TIME_PVT.DELETE_TPG_DELIMITED(

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

2111: g_tgdv_ext_rec := l_tgdv_ext_rec;
2112: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2113: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2114: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2115: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2116: raise OKC_API.G_EXCEPTION_ERROR;
2117: END IF;
2118: OKC_TIME_PVT.DELETE_TPG_DELIMITED(
2119: p_api_version,

Line 2116: raise OKC_API.G_EXCEPTION_ERROR;

2112: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2113: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2114: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2115: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2116: raise OKC_API.G_EXCEPTION_ERROR;
2117: END IF;
2118: OKC_TIME_PVT.DELETE_TPG_DELIMITED(
2119: p_api_version,
2120: p_init_msg_list,

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

2121: x_return_status,
2122: x_msg_count,
2123: x_msg_data,
2124: p_tgdv_ext_rec);
2125: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2126: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2127: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2128: raise OKC_API.G_EXCEPTION_ERROR;
2129: END IF;

Line 2126: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2122: x_msg_count,
2123: x_msg_data,
2124: p_tgdv_ext_rec);
2125: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2126: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2127: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2128: raise OKC_API.G_EXCEPTION_ERROR;
2129: END IF;
2130:

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

2123: x_msg_data,
2124: p_tgdv_ext_rec);
2125: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2126: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2127: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2128: raise OKC_API.G_EXCEPTION_ERROR;
2129: END IF;
2130:
2131: -- Call user hook for AFTER

Line 2128: raise OKC_API.G_EXCEPTION_ERROR;

2124: p_tgdv_ext_rec);
2125: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2126: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2127: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2128: raise OKC_API.G_EXCEPTION_ERROR;
2129: END IF;
2130:
2131: -- Call user hook for AFTER
2132: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');

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

2129: END IF;
2130:
2131: -- Call user hook for AFTER
2132: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2133: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2134: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2135: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2136: raise OKC_API.G_EXCEPTION_ERROR;
2137: END IF;

Line 2134: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2130:
2131: -- Call user hook for AFTER
2132: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2133: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2134: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2135: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2136: raise OKC_API.G_EXCEPTION_ERROR;
2137: END IF;
2138: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2131: -- Call user hook for AFTER
2132: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2133: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2134: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2135: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2136: raise OKC_API.G_EXCEPTION_ERROR;
2137: END IF;
2138: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2139: EXCEPTION

Line 2136: raise OKC_API.G_EXCEPTION_ERROR;

2132: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2133: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2134: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2135: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2136: raise OKC_API.G_EXCEPTION_ERROR;
2137: END IF;
2138: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2139: EXCEPTION
2140: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2134: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2135: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2136: raise OKC_API.G_EXCEPTION_ERROR;
2137: END IF;
2138: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2139: EXCEPTION
2140: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2142: (l_api_name,

Line 2140: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2136: raise OKC_API.G_EXCEPTION_ERROR;
2137: END IF;
2138: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2139: EXCEPTION
2140: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2142: (l_api_name,
2143: G_PKG_NAME,
2144: 'OKC_API.G_RET_STS_ERROR',

Line 2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2137: END IF;
2138: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2139: EXCEPTION
2140: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2142: (l_api_name,
2143: G_PKG_NAME,
2144: 'OKC_API.G_RET_STS_ERROR',
2145: x_msg_count,

Line 2144: 'OKC_API.G_RET_STS_ERROR',

2140: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2141: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2142: (l_api_name,
2143: G_PKG_NAME,
2144: 'OKC_API.G_RET_STS_ERROR',
2145: x_msg_count,
2146: x_msg_data,
2147: '_PUB');
2148: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2148: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2144: 'OKC_API.G_RET_STS_ERROR',
2145: x_msg_count,
2146: x_msg_data,
2147: '_PUB');
2148: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2149: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2150: (l_api_name,
2151: G_PKG_NAME,
2152: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2149: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2145: x_msg_count,
2146: x_msg_data,
2147: '_PUB');
2148: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2149: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2150: (l_api_name,
2151: G_PKG_NAME,
2152: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2153: x_msg_count,

Line 2152: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2148: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2149: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2150: (l_api_name,
2151: G_PKG_NAME,
2152: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2153: x_msg_count,
2154: x_msg_data,
2155: '_PUB');
2156: WHEN OTHERS THEN

Line 2157: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2153: x_msg_count,
2154: x_msg_data,
2155: '_PUB');
2156: WHEN OTHERS THEN
2157: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2158: (l_api_name,
2159: G_PKG_NAME,
2160: 'OTHERS',
2161: x_msg_count,

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

2170: x_msg_count OUT NOCOPY NUMBER,
2171: x_msg_data OUT NOCOPY VARCHAR2,
2172: p_tgdv_ext_tbl IN tgdv_ext_tbl_type) IS
2173: i NUMBER := 0;
2174: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2175: BEGIN
2176: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2177: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2178: i := p_tgdv_ext_tbl.FIRST;

Line 2176: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2172: p_tgdv_ext_tbl IN tgdv_ext_tbl_type) IS
2173: i NUMBER := 0;
2174: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2175: BEGIN
2176: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2177: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2178: i := p_tgdv_ext_tbl.FIRST;
2179: LOOP
2180: DELETE_TPG_DELIMITED(

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

2183: l_return_status,
2184: x_msg_count,
2185: x_msg_data,
2186: p_tgdv_ext_tbl(i));
2187: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2188: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2189: x_return_status := l_return_status;
2190: raise G_EXCEPTION_HALT_VALIDATION;
2191: ELSE

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

2184: x_msg_count,
2185: x_msg_data,
2186: p_tgdv_ext_tbl(i));
2187: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2188: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2189: x_return_status := l_return_status;
2190: raise G_EXCEPTION_HALT_VALIDATION;
2191: ELSE
2192: x_return_status := l_return_status;

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

2199: EXCEPTION
2200: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2201: NULL;
2202: WHEN OTHERS THEN
2203: OKC_API.set_message(p_app_name => g_app_name,
2204: p_msg_name => g_unexpected_error,
2205: p_token1 => g_sqlcode_token,
2206: p_token1_value => sqlcode,
2207: p_token2 => g_sqlerrm_token,

Line 2209: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2205: p_token1 => g_sqlcode_token,
2206: p_token1_value => sqlcode,
2207: p_token2 => g_sqlerrm_token,
2208: p_token2_value => sqlerrm);
2209: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2210: END DELETE_TPG_DELIMITED;
2211:
2212: PROCEDURE LOCK_TPG_DELIMITED(
2213: p_api_version IN NUMBER,

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

2233: x_msg_count OUT NOCOPY NUMBER,
2234: x_msg_data OUT NOCOPY VARCHAR2,
2235: p_tgdv_ext_tbl IN tgdv_ext_tbl_type) IS
2236: i NUMBER := 0;
2237: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2238: BEGIN
2239: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2240: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2241: i := p_tgdv_ext_tbl.FIRST;

Line 2239: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2235: p_tgdv_ext_tbl IN tgdv_ext_tbl_type) IS
2236: i NUMBER := 0;
2237: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2238: BEGIN
2239: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2240: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2241: i := p_tgdv_ext_tbl.FIRST;
2242: LOOP
2243: LOCK_TPG_DELIMITED(

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

2246: l_return_status,
2247: x_msg_count,
2248: x_msg_data,
2249: p_tgdv_ext_tbl(i));
2250: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2251: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2252: x_return_status := l_return_status;
2253: raise G_EXCEPTION_HALT_VALIDATION;
2254: ELSE

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

2247: x_msg_count,
2248: x_msg_data,
2249: p_tgdv_ext_tbl(i));
2250: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2251: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2252: x_return_status := l_return_status;
2253: raise G_EXCEPTION_HALT_VALIDATION;
2254: ELSE
2255: x_return_status := l_return_status;

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

2262: EXCEPTION
2263: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2264: NULL;
2265: WHEN OTHERS THEN
2266: OKC_API.set_message(p_app_name => g_app_name,
2267: p_msg_name => g_unexpected_error,
2268: p_token1 => g_sqlcode_token,
2269: p_token1_value => sqlcode,
2270: p_token2 => g_sqlerrm_token,

Line 2272: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2268: p_token1 => g_sqlcode_token,
2269: p_token1_value => sqlcode,
2270: p_token2 => g_sqlerrm_token,
2271: p_token2_value => sqlerrm);
2272: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2273: END LOCK_TPG_DELIMITED;
2274:
2275: PROCEDURE VALID_TPG_DELIMITED(
2276: p_api_version IN NUMBER,

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

2296: x_msg_count OUT NOCOPY NUMBER,
2297: x_msg_data OUT NOCOPY VARCHAR2,
2298: p_tgdv_ext_tbl IN tgdv_ext_tbl_type) IS
2299: i NUMBER := 0;
2300: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2301: BEGIN
2302: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2303: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2304: i := p_tgdv_ext_tbl.FIRST;

Line 2302: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2298: p_tgdv_ext_tbl IN tgdv_ext_tbl_type) IS
2299: i NUMBER := 0;
2300: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2301: BEGIN
2302: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2303: IF p_tgdv_ext_tbl.COUNT > 0 THEN
2304: i := p_tgdv_ext_tbl.FIRST;
2305: LOOP
2306: VALID_TPG_DELIMITED(

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

2309: l_return_status,
2310: x_msg_count,
2311: x_msg_data,
2312: p_tgdv_ext_tbl(i));
2313: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2314: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2315: x_return_status := l_return_status;
2316: raise G_EXCEPTION_HALT_VALIDATION;
2317: ELSE

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

2310: x_msg_count,
2311: x_msg_data,
2312: p_tgdv_ext_tbl(i));
2313: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2314: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2315: x_return_status := l_return_status;
2316: raise G_EXCEPTION_HALT_VALIDATION;
2317: ELSE
2318: x_return_status := l_return_status;

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

2325: EXCEPTION
2326: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2327: NULL;
2328: WHEN OTHERS THEN
2329: OKC_API.set_message(p_app_name => g_app_name,
2330: p_msg_name => g_unexpected_error,
2331: p_token1 => g_sqlcode_token,
2332: p_token1_value => sqlcode,
2333: p_token2 => g_sqlerrm_token,

Line 2335: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2331: p_token1 => g_sqlcode_token,
2332: p_token1_value => sqlcode,
2333: p_token2 => g_sqlerrm_token,
2334: p_token2_value => sqlerrm);
2335: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2336: END VALID_TPG_DELIMITED;
2337:
2338: --------------------------------------------------------------------------
2339: ---The following procedures cater to handling of OKC_TIME_TPG_NAMED

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

2415: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_TPG_NAMED';
2416: l_return_status VARCHAR2(1);
2417: l_tgnv_rec tgnv_rec_type := p_tgnv_rec;
2418: BEGIN
2419: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2420: p_init_msg_list,
2421: '_PUB',
2422: x_return_status);
2423: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2419: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2420: p_init_msg_list,
2421: '_PUB',
2422: x_return_status);
2423: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2424: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2425: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2426: raise OKC_API.G_EXCEPTION_ERROR;
2427: END IF;

Line 2424: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2420: p_init_msg_list,
2421: '_PUB',
2422: x_return_status);
2423: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2424: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2425: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2426: raise OKC_API.G_EXCEPTION_ERROR;
2427: END IF;
2428: -- Call user hook for BEFORE

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

2421: '_PUB',
2422: x_return_status);
2423: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2424: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2425: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2426: raise OKC_API.G_EXCEPTION_ERROR;
2427: END IF;
2428: -- Call user hook for BEFORE
2429: g_tgnv_rec := l_tgnv_rec;

Line 2426: raise OKC_API.G_EXCEPTION_ERROR;

2422: x_return_status);
2423: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2424: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2425: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2426: raise OKC_API.G_EXCEPTION_ERROR;
2427: END IF;
2428: -- Call user hook for BEFORE
2429: g_tgnv_rec := l_tgnv_rec;
2430: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

2427: END IF;
2428: -- Call user hook for BEFORE
2429: g_tgnv_rec := l_tgnv_rec;
2430: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_ERROR;
2435: END IF;

Line 2432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2428: -- Call user hook for BEFORE
2429: g_tgnv_rec := l_tgnv_rec;
2430: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_ERROR;
2435: END IF;
2436: l_tgnv_rec := migrate_tgnv(l_tgnv_rec, g_tgnv_rec);

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

2429: g_tgnv_rec := l_tgnv_rec;
2430: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_ERROR;
2435: END IF;
2436: l_tgnv_rec := migrate_tgnv(l_tgnv_rec, g_tgnv_rec);
2437: OKC_TIME_PVT.CREATE_TPG_NAMED(

Line 2434: raise OKC_API.G_EXCEPTION_ERROR;

2430: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2431: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2432: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2433: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2434: raise OKC_API.G_EXCEPTION_ERROR;
2435: END IF;
2436: l_tgnv_rec := migrate_tgnv(l_tgnv_rec, g_tgnv_rec);
2437: OKC_TIME_PVT.CREATE_TPG_NAMED(
2438: p_api_version,

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

2441: x_msg_count,
2442: x_msg_data,
2443: p_tgnv_rec,
2444: x_tgnv_rec);
2445: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2446: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2447: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2448: raise OKC_API.G_EXCEPTION_ERROR;
2449: END IF;

Line 2446: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2442: x_msg_data,
2443: p_tgnv_rec,
2444: x_tgnv_rec);
2445: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2446: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2447: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2448: raise OKC_API.G_EXCEPTION_ERROR;
2449: END IF;
2450:

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

2443: p_tgnv_rec,
2444: x_tgnv_rec);
2445: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2446: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2447: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2448: raise OKC_API.G_EXCEPTION_ERROR;
2449: END IF;
2450:
2451: -- Call user hook for AFTER

Line 2448: raise OKC_API.G_EXCEPTION_ERROR;

2444: x_tgnv_rec);
2445: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2446: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2447: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2448: raise OKC_API.G_EXCEPTION_ERROR;
2449: END IF;
2450:
2451: -- Call user hook for AFTER
2452: g_tgnv_rec := x_tgnv_rec;

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

2450:
2451: -- Call user hook for AFTER
2452: g_tgnv_rec := x_tgnv_rec;
2453: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2454: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2455: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2456: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2457: raise OKC_API.G_EXCEPTION_ERROR;
2458: END IF;

Line 2455: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2451: -- Call user hook for AFTER
2452: g_tgnv_rec := x_tgnv_rec;
2453: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2454: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2455: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2456: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2457: raise OKC_API.G_EXCEPTION_ERROR;
2458: END IF;
2459: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2452: g_tgnv_rec := x_tgnv_rec;
2453: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2454: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2455: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2456: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2457: raise OKC_API.G_EXCEPTION_ERROR;
2458: END IF;
2459: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2460: EXCEPTION

Line 2457: raise OKC_API.G_EXCEPTION_ERROR;

2453: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2454: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2455: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2456: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2457: raise OKC_API.G_EXCEPTION_ERROR;
2458: END IF;
2459: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2460: EXCEPTION
2461: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2455: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2456: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2457: raise OKC_API.G_EXCEPTION_ERROR;
2458: END IF;
2459: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2460: EXCEPTION
2461: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2462: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2463: (l_api_name,

Line 2461: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2457: raise OKC_API.G_EXCEPTION_ERROR;
2458: END IF;
2459: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2460: EXCEPTION
2461: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2462: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2463: (l_api_name,
2464: G_PKG_NAME,
2465: 'OKC_API.G_RET_STS_ERROR',

Line 2462: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2458: END IF;
2459: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2460: EXCEPTION
2461: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2462: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2463: (l_api_name,
2464: G_PKG_NAME,
2465: 'OKC_API.G_RET_STS_ERROR',
2466: x_msg_count,

Line 2465: 'OKC_API.G_RET_STS_ERROR',

2461: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2462: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2463: (l_api_name,
2464: G_PKG_NAME,
2465: 'OKC_API.G_RET_STS_ERROR',
2466: x_msg_count,
2467: x_msg_data,
2468: '_PUB');
2469: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2469: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2465: 'OKC_API.G_RET_STS_ERROR',
2466: x_msg_count,
2467: x_msg_data,
2468: '_PUB');
2469: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2470: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2471: (l_api_name,
2472: G_PKG_NAME,
2473: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2470: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2466: x_msg_count,
2467: x_msg_data,
2468: '_PUB');
2469: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2470: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2471: (l_api_name,
2472: G_PKG_NAME,
2473: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2474: x_msg_count,

Line 2473: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2469: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2470: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2471: (l_api_name,
2472: G_PKG_NAME,
2473: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2474: x_msg_count,
2475: x_msg_data,
2476: '_PUB');
2477: WHEN OTHERS THEN

Line 2478: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2474: x_msg_count,
2475: x_msg_data,
2476: '_PUB');
2477: WHEN OTHERS THEN
2478: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2479: (l_api_name,
2480: G_PKG_NAME,
2481: 'OTHERS',
2482: x_msg_count,

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

2492: x_msg_data OUT NOCOPY VARCHAR2,
2493: p_tgnv_tbl IN tgnv_tbl_type,
2494: x_tgnv_tbl OUT NOCOPY tgnv_tbl_type) IS
2495: i NUMBER := 0;
2496: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2497: BEGIN
2498: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2499: IF p_tgnv_tbl.COUNT > 0 THEN
2500: i := p_tgnv_tbl.FIRST;

Line 2498: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2494: x_tgnv_tbl OUT NOCOPY tgnv_tbl_type) IS
2495: i NUMBER := 0;
2496: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2497: BEGIN
2498: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2499: IF p_tgnv_tbl.COUNT > 0 THEN
2500: i := p_tgnv_tbl.FIRST;
2501: LOOP
2502: CREATE_TPG_NAMED(

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

2506: x_msg_count,
2507: x_msg_data,
2508: p_tgnv_tbl(i),
2509: x_tgnv_tbl(i));
2510: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2511: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2512: x_return_status := l_return_status;
2513: raise G_EXCEPTION_HALT_VALIDATION;
2514: ELSE

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

2507: x_msg_data,
2508: p_tgnv_tbl(i),
2509: x_tgnv_tbl(i));
2510: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2511: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2512: x_return_status := l_return_status;
2513: raise G_EXCEPTION_HALT_VALIDATION;
2514: ELSE
2515: x_return_status := l_return_status;

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

2522: EXCEPTION
2523: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2524: NULL;
2525: WHEN OTHERS THEN
2526: OKC_API.set_message(p_app_name => g_app_name,
2527: p_msg_name => g_unexpected_error,
2528: p_token1 => g_sqlcode_token,
2529: p_token1_value => sqlcode,
2530: p_token2 => g_sqlerrm_token,

Line 2532: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2528: p_token1 => g_sqlcode_token,
2529: p_token1_value => sqlcode,
2530: p_token2 => g_sqlerrm_token,
2531: p_token2_value => sqlerrm);
2532: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2533: END CREATE_TPG_NAMED;
2534:
2535: PROCEDURE UPDATE_TPG_NAMED(
2536: p_api_version IN NUMBER,

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

2543: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_TPG_NAMED';
2544: l_return_status VARCHAR2(1);
2545: l_tgnv_rec tgnv_rec_type := p_tgnv_rec;
2546: BEGIN
2547: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2548: p_init_msg_list,
2549: '_PUB',
2550: x_return_status);
2551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2547: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2548: p_init_msg_list,
2549: '_PUB',
2550: x_return_status);
2551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2554: raise OKC_API.G_EXCEPTION_ERROR;
2555: END IF;

Line 2552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2548: p_init_msg_list,
2549: '_PUB',
2550: x_return_status);
2551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2554: raise OKC_API.G_EXCEPTION_ERROR;
2555: END IF;
2556: -- Call user hook for BEFORE

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

2549: '_PUB',
2550: x_return_status);
2551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2554: raise OKC_API.G_EXCEPTION_ERROR;
2555: END IF;
2556: -- Call user hook for BEFORE
2557: g_tgnv_rec := l_tgnv_rec;

Line 2554: raise OKC_API.G_EXCEPTION_ERROR;

2550: x_return_status);
2551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2554: raise OKC_API.G_EXCEPTION_ERROR;
2555: END IF;
2556: -- Call user hook for BEFORE
2557: g_tgnv_rec := l_tgnv_rec;
2558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

2555: END IF;
2556: -- Call user hook for BEFORE
2557: g_tgnv_rec := l_tgnv_rec;
2558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2562: raise OKC_API.G_EXCEPTION_ERROR;
2563: END IF;

Line 2560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2556: -- Call user hook for BEFORE
2557: g_tgnv_rec := l_tgnv_rec;
2558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2562: raise OKC_API.G_EXCEPTION_ERROR;
2563: END IF;
2564: l_tgnv_rec := migrate_tgnv(l_tgnv_rec, g_tgnv_rec);

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

2557: g_tgnv_rec := l_tgnv_rec;
2558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2562: raise OKC_API.G_EXCEPTION_ERROR;
2563: END IF;
2564: l_tgnv_rec := migrate_tgnv(l_tgnv_rec, g_tgnv_rec);
2565: OKC_TIME_PVT.UPDATE_TPG_NAMED(

Line 2562: raise OKC_API.G_EXCEPTION_ERROR;

2558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2562: raise OKC_API.G_EXCEPTION_ERROR;
2563: END IF;
2564: l_tgnv_rec := migrate_tgnv(l_tgnv_rec, g_tgnv_rec);
2565: OKC_TIME_PVT.UPDATE_TPG_NAMED(
2566: p_api_version,

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

2569: x_msg_count,
2570: x_msg_data,
2571: p_tgnv_rec,
2572: x_tgnv_rec);
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;

Line 2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2570: x_msg_data,
2571: p_tgnv_rec,
2572: x_tgnv_rec);
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578:

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

2571: p_tgnv_rec,
2572: x_tgnv_rec);
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578:
2579: -- Call user hook for AFTER

Line 2576: raise OKC_API.G_EXCEPTION_ERROR;

2572: x_tgnv_rec);
2573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2576: raise OKC_API.G_EXCEPTION_ERROR;
2577: END IF;
2578:
2579: -- Call user hook for AFTER
2580: g_tgnv_rec := x_tgnv_rec;

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

2578:
2579: -- Call user hook for AFTER
2580: g_tgnv_rec := x_tgnv_rec;
2581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2585: raise OKC_API.G_EXCEPTION_ERROR;
2586: END IF;

Line 2583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2579: -- Call user hook for AFTER
2580: g_tgnv_rec := x_tgnv_rec;
2581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2585: raise OKC_API.G_EXCEPTION_ERROR;
2586: END IF;
2587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2580: g_tgnv_rec := x_tgnv_rec;
2581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2585: raise OKC_API.G_EXCEPTION_ERROR;
2586: END IF;
2587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2588: EXCEPTION

Line 2585: raise OKC_API.G_EXCEPTION_ERROR;

2581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2585: raise OKC_API.G_EXCEPTION_ERROR;
2586: END IF;
2587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2588: EXCEPTION
2589: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2585: raise OKC_API.G_EXCEPTION_ERROR;
2586: END IF;
2587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2588: EXCEPTION
2589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2591: (l_api_name,

Line 2589: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2585: raise OKC_API.G_EXCEPTION_ERROR;
2586: END IF;
2587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2588: EXCEPTION
2589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2591: (l_api_name,
2592: G_PKG_NAME,
2593: 'OKC_API.G_RET_STS_ERROR',

Line 2590: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2586: END IF;
2587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2588: EXCEPTION
2589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2591: (l_api_name,
2592: G_PKG_NAME,
2593: 'OKC_API.G_RET_STS_ERROR',
2594: x_msg_count,

Line 2593: 'OKC_API.G_RET_STS_ERROR',

2589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2591: (l_api_name,
2592: G_PKG_NAME,
2593: 'OKC_API.G_RET_STS_ERROR',
2594: x_msg_count,
2595: x_msg_data,
2596: '_PUB');
2597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2593: 'OKC_API.G_RET_STS_ERROR',
2594: x_msg_count,
2595: x_msg_data,
2596: '_PUB');
2597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2598: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2599: (l_api_name,
2600: G_PKG_NAME,
2601: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2598: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2594: x_msg_count,
2595: x_msg_data,
2596: '_PUB');
2597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2598: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2599: (l_api_name,
2600: G_PKG_NAME,
2601: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2602: x_msg_count,

Line 2601: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2598: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2599: (l_api_name,
2600: G_PKG_NAME,
2601: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2602: x_msg_count,
2603: x_msg_data,
2604: '_PUB');
2605: WHEN OTHERS THEN

Line 2606: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2602: x_msg_count,
2603: x_msg_data,
2604: '_PUB');
2605: WHEN OTHERS THEN
2606: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2607: (l_api_name,
2608: G_PKG_NAME,
2609: 'OTHERS',
2610: x_msg_count,

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

2620: x_msg_data OUT NOCOPY VARCHAR2,
2621: p_tgnv_tbl IN tgnv_tbl_type,
2622: x_tgnv_tbl OUT NOCOPY tgnv_tbl_type) IS
2623: i NUMBER := 0;
2624: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2625: BEGIN
2626: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2627: IF p_tgnv_tbl.COUNT > 0 THEN
2628: i := p_tgnv_tbl.FIRST;

Line 2626: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2622: x_tgnv_tbl OUT NOCOPY tgnv_tbl_type) IS
2623: i NUMBER := 0;
2624: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2625: BEGIN
2626: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2627: IF p_tgnv_tbl.COUNT > 0 THEN
2628: i := p_tgnv_tbl.FIRST;
2629: LOOP
2630: UPDATE_TPG_NAMED(

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

2634: x_msg_count,
2635: x_msg_data,
2636: p_tgnv_tbl(i),
2637: x_tgnv_tbl(i));
2638: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2639: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2640: x_return_status := l_return_status;
2641: raise G_EXCEPTION_HALT_VALIDATION;
2642: ELSE

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

2635: x_msg_data,
2636: p_tgnv_tbl(i),
2637: x_tgnv_tbl(i));
2638: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2639: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2640: x_return_status := l_return_status;
2641: raise G_EXCEPTION_HALT_VALIDATION;
2642: ELSE
2643: x_return_status := l_return_status;

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

2650: EXCEPTION
2651: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2652: NULL;
2653: WHEN OTHERS THEN
2654: OKC_API.set_message(p_app_name => g_app_name,
2655: p_msg_name => g_unexpected_error,
2656: p_token1 => g_sqlcode_token,
2657: p_token1_value => sqlcode,
2658: p_token2 => g_sqlerrm_token,

Line 2660: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2656: p_token1 => g_sqlcode_token,
2657: p_token1_value => sqlcode,
2658: p_token2 => g_sqlerrm_token,
2659: p_token2_value => sqlerrm);
2660: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2661: END UPDATE_TPG_NAMED;
2662:
2663: PROCEDURE DELETE_TPG_NAMED(
2664: p_api_version IN NUMBER,

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

2670: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_TPG_NAMED';
2671: l_return_status VARCHAR2(1);
2672: l_tgnv_rec tgnv_rec_type := p_tgnv_rec;
2673: BEGIN
2674: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2675: p_init_msg_list,
2676: '_PUB',
2677: x_return_status);
2678: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

2674: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
2675: p_init_msg_list,
2676: '_PUB',
2677: x_return_status);
2678: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2679: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2680: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2681: raise OKC_API.G_EXCEPTION_ERROR;
2682: END IF;

Line 2679: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2675: p_init_msg_list,
2676: '_PUB',
2677: x_return_status);
2678: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2679: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2680: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2681: raise OKC_API.G_EXCEPTION_ERROR;
2682: END IF;
2683: -- Call user hook for BEFORE

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

2676: '_PUB',
2677: x_return_status);
2678: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2679: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2680: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2681: raise OKC_API.G_EXCEPTION_ERROR;
2682: END IF;
2683: -- Call user hook for BEFORE
2684: g_tgnv_rec := l_tgnv_rec;

Line 2681: raise OKC_API.G_EXCEPTION_ERROR;

2677: x_return_status);
2678: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2679: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2680: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
2681: raise OKC_API.G_EXCEPTION_ERROR;
2682: END IF;
2683: -- Call user hook for BEFORE
2684: g_tgnv_rec := l_tgnv_rec;
2685: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

2682: END IF;
2683: -- Call user hook for BEFORE
2684: g_tgnv_rec := l_tgnv_rec;
2685: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2686: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2687: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2688: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2689: raise OKC_API.G_EXCEPTION_ERROR;
2690: END IF;

Line 2687: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2683: -- Call user hook for BEFORE
2684: g_tgnv_rec := l_tgnv_rec;
2685: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2686: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2687: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2688: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2689: raise OKC_API.G_EXCEPTION_ERROR;
2690: END IF;
2691: OKC_TIME_PVT.DELETE_TPG_NAMED(

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

2684: g_tgnv_rec := l_tgnv_rec;
2685: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2686: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2687: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2688: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2689: raise OKC_API.G_EXCEPTION_ERROR;
2690: END IF;
2691: OKC_TIME_PVT.DELETE_TPG_NAMED(
2692: p_api_version,

Line 2689: raise OKC_API.G_EXCEPTION_ERROR;

2685: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
2686: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2687: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2688: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2689: raise OKC_API.G_EXCEPTION_ERROR;
2690: END IF;
2691: OKC_TIME_PVT.DELETE_TPG_NAMED(
2692: p_api_version,
2693: p_init_msg_list,

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

2694: x_return_status,
2695: x_msg_count,
2696: x_msg_data,
2697: p_tgnv_rec);
2698: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2699: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2700: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2701: raise OKC_API.G_EXCEPTION_ERROR;
2702: END IF;

Line 2699: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2695: x_msg_count,
2696: x_msg_data,
2697: p_tgnv_rec);
2698: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2699: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2700: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2701: raise OKC_API.G_EXCEPTION_ERROR;
2702: END IF;
2703:

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

2696: x_msg_data,
2697: p_tgnv_rec);
2698: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2699: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2700: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2701: raise OKC_API.G_EXCEPTION_ERROR;
2702: END IF;
2703:
2704: -- Call user hook for AFTER

Line 2701: raise OKC_API.G_EXCEPTION_ERROR;

2697: p_tgnv_rec);
2698: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2699: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2700: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2701: raise OKC_API.G_EXCEPTION_ERROR;
2702: END IF;
2703:
2704: -- Call user hook for AFTER
2705: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');

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

2702: END IF;
2703:
2704: -- Call user hook for AFTER
2705: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2706: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2708: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2709: raise OKC_API.G_EXCEPTION_ERROR;
2710: END IF;

Line 2707: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

2703:
2704: -- Call user hook for AFTER
2705: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2706: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2708: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2709: raise OKC_API.G_EXCEPTION_ERROR;
2710: END IF;
2711: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

2704: -- Call user hook for AFTER
2705: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2706: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2708: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2709: raise OKC_API.G_EXCEPTION_ERROR;
2710: END IF;
2711: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2712: EXCEPTION

Line 2709: raise OKC_API.G_EXCEPTION_ERROR;

2705: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
2706: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2707: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2708: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2709: raise OKC_API.G_EXCEPTION_ERROR;
2710: END IF;
2711: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2712: EXCEPTION
2713: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

2707: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
2708: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
2709: raise OKC_API.G_EXCEPTION_ERROR;
2710: END IF;
2711: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2712: EXCEPTION
2713: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2714: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2715: (l_api_name,

Line 2713: WHEN OKC_API.G_EXCEPTION_ERROR THEN

2709: raise OKC_API.G_EXCEPTION_ERROR;
2710: END IF;
2711: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2712: EXCEPTION
2713: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2714: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2715: (l_api_name,
2716: G_PKG_NAME,
2717: 'OKC_API.G_RET_STS_ERROR',

Line 2714: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2710: END IF;
2711: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
2712: EXCEPTION
2713: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2714: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2715: (l_api_name,
2716: G_PKG_NAME,
2717: 'OKC_API.G_RET_STS_ERROR',
2718: x_msg_count,

Line 2717: 'OKC_API.G_RET_STS_ERROR',

2713: WHEN OKC_API.G_EXCEPTION_ERROR THEN
2714: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2715: (l_api_name,
2716: G_PKG_NAME,
2717: 'OKC_API.G_RET_STS_ERROR',
2718: x_msg_count,
2719: x_msg_data,
2720: '_PUB');
2721: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 2721: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

2717: 'OKC_API.G_RET_STS_ERROR',
2718: x_msg_count,
2719: x_msg_data,
2720: '_PUB');
2721: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2722: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2723: (l_api_name,
2724: G_PKG_NAME,
2725: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 2722: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2718: x_msg_count,
2719: x_msg_data,
2720: '_PUB');
2721: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2722: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2723: (l_api_name,
2724: G_PKG_NAME,
2725: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2726: x_msg_count,

Line 2725: 'OKC_API.G_RET_STS_UNEXP_ERROR',

2721: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
2722: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2723: (l_api_name,
2724: G_PKG_NAME,
2725: 'OKC_API.G_RET_STS_UNEXP_ERROR',
2726: x_msg_count,
2727: x_msg_data,
2728: '_PUB');
2729: WHEN OTHERS THEN

Line 2730: x_return_status := OKC_API.HANDLE_EXCEPTIONS

2726: x_msg_count,
2727: x_msg_data,
2728: '_PUB');
2729: WHEN OTHERS THEN
2730: x_return_status := OKC_API.HANDLE_EXCEPTIONS
2731: (l_api_name,
2732: G_PKG_NAME,
2733: 'OTHERS',
2734: x_msg_count,

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

2743: x_msg_count OUT NOCOPY NUMBER,
2744: x_msg_data OUT NOCOPY VARCHAR2,
2745: p_tgnv_tbl IN tgnv_tbl_type) IS
2746: i NUMBER := 0;
2747: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2748: BEGIN
2749: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2750: IF p_tgnv_tbl.COUNT > 0 THEN
2751: i := p_tgnv_tbl.FIRST;

Line 2749: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2745: p_tgnv_tbl IN tgnv_tbl_type) IS
2746: i NUMBER := 0;
2747: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2748: BEGIN
2749: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2750: IF p_tgnv_tbl.COUNT > 0 THEN
2751: i := p_tgnv_tbl.FIRST;
2752: LOOP
2753: DELETE_TPG_NAMED(

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

2756: l_return_status,
2757: x_msg_count,
2758: x_msg_data,
2759: p_tgnv_tbl(i));
2760: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2761: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2762: x_return_status := l_return_status;
2763: raise G_EXCEPTION_HALT_VALIDATION;
2764: ELSE

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

2757: x_msg_count,
2758: x_msg_data,
2759: p_tgnv_tbl(i));
2760: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2761: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2762: x_return_status := l_return_status;
2763: raise G_EXCEPTION_HALT_VALIDATION;
2764: ELSE
2765: x_return_status := l_return_status;

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

2772: EXCEPTION
2773: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2774: NULL;
2775: WHEN OTHERS THEN
2776: OKC_API.set_message(p_app_name => g_app_name,
2777: p_msg_name => g_unexpected_error,
2778: p_token1 => g_sqlcode_token,
2779: p_token1_value => sqlcode,
2780: p_token2 => g_sqlerrm_token,

Line 2782: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2778: p_token1 => g_sqlcode_token,
2779: p_token1_value => sqlcode,
2780: p_token2 => g_sqlerrm_token,
2781: p_token2_value => sqlerrm);
2782: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2783: END DELETE_TPG_NAMED;
2784:
2785: PROCEDURE LOCK_TPG_NAMED(
2786: p_api_version IN NUMBER,

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

2806: x_msg_count OUT NOCOPY NUMBER,
2807: x_msg_data OUT NOCOPY VARCHAR2,
2808: p_tgnv_tbl IN tgnv_tbl_type) IS
2809: i NUMBER := 0;
2810: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2811: BEGIN
2812: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2813: IF p_tgnv_tbl.COUNT > 0 THEN
2814: i := p_tgnv_tbl.FIRST;

Line 2812: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2808: p_tgnv_tbl IN tgnv_tbl_type) IS
2809: i NUMBER := 0;
2810: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2811: BEGIN
2812: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2813: IF p_tgnv_tbl.COUNT > 0 THEN
2814: i := p_tgnv_tbl.FIRST;
2815: LOOP
2816: LOCK_TPG_NAMED(

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

2819: l_return_status,
2820: x_msg_count,
2821: x_msg_data,
2822: p_tgnv_tbl(i));
2823: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2824: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2825: x_return_status := l_return_status;
2826: raise G_EXCEPTION_HALT_VALIDATION;
2827: ELSE

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

2820: x_msg_count,
2821: x_msg_data,
2822: p_tgnv_tbl(i));
2823: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2824: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2825: x_return_status := l_return_status;
2826: raise G_EXCEPTION_HALT_VALIDATION;
2827: ELSE
2828: x_return_status := l_return_status;

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

2835: EXCEPTION
2836: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2837: NULL;
2838: WHEN OTHERS THEN
2839: OKC_API.set_message(p_app_name => g_app_name,
2840: p_msg_name => g_unexpected_error,
2841: p_token1 => g_sqlcode_token,
2842: p_token1_value => sqlcode,
2843: p_token2 => g_sqlerrm_token,

Line 2845: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2841: p_token1 => g_sqlcode_token,
2842: p_token1_value => sqlcode,
2843: p_token2 => g_sqlerrm_token,
2844: p_token2_value => sqlerrm);
2845: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2846: END LOCK_TPG_NAMED;
2847:
2848: PROCEDURE VALID_TPG_NAMED(
2849: p_api_version IN NUMBER,

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

2869: x_msg_count OUT NOCOPY NUMBER,
2870: x_msg_data OUT NOCOPY VARCHAR2,
2871: p_tgnv_tbl IN tgnv_tbl_type) IS
2872: i NUMBER := 0;
2873: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2874: BEGIN
2875: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2876: IF p_tgnv_tbl.COUNT > 0 THEN
2877: i := p_tgnv_tbl.FIRST;

Line 2875: x_return_status := OKC_API.G_RET_STS_SUCCESS;

2871: p_tgnv_tbl IN tgnv_tbl_type) IS
2872: i NUMBER := 0;
2873: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
2874: BEGIN
2875: x_return_status := OKC_API.G_RET_STS_SUCCESS;
2876: IF p_tgnv_tbl.COUNT > 0 THEN
2877: i := p_tgnv_tbl.FIRST;
2878: LOOP
2879: VALID_TPG_NAMED(

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

2882: l_return_status,
2883: x_msg_count,
2884: x_msg_data,
2885: p_tgnv_tbl(i));
2886: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2887: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2888: x_return_status := l_return_status;
2889: raise G_EXCEPTION_HALT_VALIDATION;
2890: ELSE

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

2883: x_msg_count,
2884: x_msg_data,
2885: p_tgnv_tbl(i));
2886: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
2887: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
2888: x_return_status := l_return_status;
2889: raise G_EXCEPTION_HALT_VALIDATION;
2890: ELSE
2891: x_return_status := l_return_status;

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

2898: EXCEPTION
2899: WHEN G_EXCEPTION_HALT_VALIDATION THEN
2900: NULL;
2901: WHEN OTHERS THEN
2902: OKC_API.set_message(p_app_name => g_app_name,
2903: p_msg_name => g_unexpected_error,
2904: p_token1 => g_sqlcode_token,
2905: p_token1_value => sqlcode,
2906: p_token2 => g_sqlerrm_token,

Line 2908: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

2904: p_token1 => g_sqlcode_token,
2905: p_token1_value => sqlcode,
2906: p_token2 => g_sqlerrm_token,
2907: p_token2_value => sqlerrm);
2908: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
2909: END VALID_TPG_NAMED;
2910:
2911: --------------------------------------------------------------------------
2912: ---The following procedures cater to handling of OKC_TIME_IA_STARTEND

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

3065: l_api_name CONSTANT VARCHAR2(30) := 'CREATE_IA_STARTEND';
3066: l_return_status VARCHAR2(1);
3067: l_isev_ext_rec isev_ext_rec_type := p_isev_ext_rec;
3068: BEGIN
3069: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3070: p_init_msg_list,
3071: '_PUB',
3072: x_return_status);
3073: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

3069: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3070: p_init_msg_list,
3071: '_PUB',
3072: x_return_status);
3073: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3074: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3075: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3076: raise OKC_API.G_EXCEPTION_ERROR;
3077: END IF;

Line 3074: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3070: p_init_msg_list,
3071: '_PUB',
3072: x_return_status);
3073: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3074: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3075: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3076: raise OKC_API.G_EXCEPTION_ERROR;
3077: END IF;
3078: -- Call user hook for BEFORE

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

3071: '_PUB',
3072: x_return_status);
3073: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3074: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3075: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3076: raise OKC_API.G_EXCEPTION_ERROR;
3077: END IF;
3078: -- Call user hook for BEFORE
3079: g_isev_ext_rec := l_isev_ext_rec;

Line 3076: raise OKC_API.G_EXCEPTION_ERROR;

3072: x_return_status);
3073: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3074: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3075: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3076: raise OKC_API.G_EXCEPTION_ERROR;
3077: END IF;
3078: -- Call user hook for BEFORE
3079: g_isev_ext_rec := l_isev_ext_rec;
3080: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

3077: END IF;
3078: -- Call user hook for BEFORE
3079: g_isev_ext_rec := l_isev_ext_rec;
3080: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3081: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3082: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3083: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3084: raise OKC_API.G_EXCEPTION_ERROR;
3085: END IF;

Line 3082: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3078: -- Call user hook for BEFORE
3079: g_isev_ext_rec := l_isev_ext_rec;
3080: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3081: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3082: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3083: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3084: raise OKC_API.G_EXCEPTION_ERROR;
3085: END IF;
3086: l_isev_ext_rec := migrate_isev(l_isev_ext_rec, g_isev_ext_rec);

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

3079: g_isev_ext_rec := l_isev_ext_rec;
3080: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3081: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3082: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3083: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3084: raise OKC_API.G_EXCEPTION_ERROR;
3085: END IF;
3086: l_isev_ext_rec := migrate_isev(l_isev_ext_rec, g_isev_ext_rec);
3087: OKC_TIME_PVT.CREATE_IA_STARTEND(

Line 3084: raise OKC_API.G_EXCEPTION_ERROR;

3080: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3081: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3082: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3083: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3084: raise OKC_API.G_EXCEPTION_ERROR;
3085: END IF;
3086: l_isev_ext_rec := migrate_isev(l_isev_ext_rec, g_isev_ext_rec);
3087: OKC_TIME_PVT.CREATE_IA_STARTEND(
3088: p_api_version,

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

3091: x_msg_count,
3092: x_msg_data,
3093: p_isev_ext_rec,
3094: x_isev_ext_rec);
3095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3096: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_ERROR;
3099: END IF;

Line 3096: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3092: x_msg_data,
3093: p_isev_ext_rec,
3094: x_isev_ext_rec);
3095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3096: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_ERROR;
3099: END IF;
3100:

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

3093: p_isev_ext_rec,
3094: x_isev_ext_rec);
3095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3096: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_ERROR;
3099: END IF;
3100:
3101: -- Call user hook for AFTER

Line 3098: raise OKC_API.G_EXCEPTION_ERROR;

3094: x_isev_ext_rec);
3095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3096: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3098: raise OKC_API.G_EXCEPTION_ERROR;
3099: END IF;
3100:
3101: -- Call user hook for AFTER
3102: g_isev_ext_rec := x_isev_ext_rec;

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

3100:
3101: -- Call user hook for AFTER
3102: g_isev_ext_rec := x_isev_ext_rec;
3103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3107: raise OKC_API.G_EXCEPTION_ERROR;
3108: END IF;

Line 3105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3101: -- Call user hook for AFTER
3102: g_isev_ext_rec := x_isev_ext_rec;
3103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3107: raise OKC_API.G_EXCEPTION_ERROR;
3108: END IF;
3109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

3102: g_isev_ext_rec := x_isev_ext_rec;
3103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3107: raise OKC_API.G_EXCEPTION_ERROR;
3108: END IF;
3109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3110: EXCEPTION

Line 3107: raise OKC_API.G_EXCEPTION_ERROR;

3103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3107: raise OKC_API.G_EXCEPTION_ERROR;
3108: END IF;
3109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3110: EXCEPTION
3111: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

3105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3107: raise OKC_API.G_EXCEPTION_ERROR;
3108: END IF;
3109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3110: EXCEPTION
3111: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3113: (l_api_name,

Line 3111: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3107: raise OKC_API.G_EXCEPTION_ERROR;
3108: END IF;
3109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3110: EXCEPTION
3111: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3113: (l_api_name,
3114: G_PKG_NAME,
3115: 'OKC_API.G_RET_STS_ERROR',

Line 3112: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3108: END IF;
3109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3110: EXCEPTION
3111: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3113: (l_api_name,
3114: G_PKG_NAME,
3115: 'OKC_API.G_RET_STS_ERROR',
3116: x_msg_count,

Line 3115: 'OKC_API.G_RET_STS_ERROR',

3111: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3113: (l_api_name,
3114: G_PKG_NAME,
3115: 'OKC_API.G_RET_STS_ERROR',
3116: x_msg_count,
3117: x_msg_data,
3118: '_PUB');
3119: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 3119: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3115: 'OKC_API.G_RET_STS_ERROR',
3116: x_msg_count,
3117: x_msg_data,
3118: '_PUB');
3119: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3120: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3121: (l_api_name,
3122: G_PKG_NAME,
3123: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3120: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3116: x_msg_count,
3117: x_msg_data,
3118: '_PUB');
3119: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3120: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3121: (l_api_name,
3122: G_PKG_NAME,
3123: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3124: x_msg_count,

Line 3123: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3119: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3120: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3121: (l_api_name,
3122: G_PKG_NAME,
3123: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3124: x_msg_count,
3125: x_msg_data,
3126: '_PUB');
3127: WHEN OTHERS THEN

Line 3128: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3124: x_msg_count,
3125: x_msg_data,
3126: '_PUB');
3127: WHEN OTHERS THEN
3128: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3129: (l_api_name,
3130: G_PKG_NAME,
3131: 'OTHERS',
3132: x_msg_count,

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

3142: x_msg_data OUT NOCOPY VARCHAR2,
3143: p_isev_ext_tbl IN isev_ext_tbl_type,
3144: x_isev_ext_tbl OUT NOCOPY isev_ext_tbl_type) IS
3145: i NUMBER := 0;
3146: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3147: BEGIN
3148: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3149: IF p_isev_ext_tbl.COUNT > 0 THEN
3150: i := p_isev_ext_tbl.FIRST;

Line 3148: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3144: x_isev_ext_tbl OUT NOCOPY isev_ext_tbl_type) IS
3145: i NUMBER := 0;
3146: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3147: BEGIN
3148: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3149: IF p_isev_ext_tbl.COUNT > 0 THEN
3150: i := p_isev_ext_tbl.FIRST;
3151: LOOP
3152: CREATE_IA_STARTEND(

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

3156: x_msg_count,
3157: x_msg_data,
3158: p_isev_ext_tbl(i),
3159: x_isev_ext_tbl(i));
3160: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3161: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3162: x_return_status := l_return_status;
3163: raise G_EXCEPTION_HALT_VALIDATION;
3164: ELSE

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

3157: x_msg_data,
3158: p_isev_ext_tbl(i),
3159: x_isev_ext_tbl(i));
3160: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3161: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3162: x_return_status := l_return_status;
3163: raise G_EXCEPTION_HALT_VALIDATION;
3164: ELSE
3165: x_return_status := l_return_status;

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

3172: EXCEPTION
3173: WHEN G_EXCEPTION_HALT_VALIDATION THEN
3174: NULL;
3175: WHEN OTHERS THEN
3176: OKC_API.set_message(p_app_name => g_app_name,
3177: p_msg_name => g_unexpected_error,
3178: p_token1 => g_sqlcode_token,
3179: p_token1_value => sqlcode,
3180: p_token2 => g_sqlerrm_token,

Line 3182: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3178: p_token1 => g_sqlcode_token,
3179: p_token1_value => sqlcode,
3180: p_token2 => g_sqlerrm_token,
3181: p_token2_value => sqlerrm);
3182: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3183: END CREATE_IA_STARTEND;
3184:
3185: PROCEDURE UPDATE_IA_STARTEND(
3186: p_api_version IN NUMBER,

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

3193: l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_IA_STARTEND';
3194: l_return_status VARCHAR2(1);
3195: l_isev_ext_rec isev_ext_rec_type := p_isev_ext_rec;
3196: BEGIN
3197: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3198: p_init_msg_list,
3199: '_PUB',
3200: x_return_status);
3201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

3197: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3198: p_init_msg_list,
3199: '_PUB',
3200: x_return_status);
3201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3202: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3204: raise OKC_API.G_EXCEPTION_ERROR;
3205: END IF;

Line 3202: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3198: p_init_msg_list,
3199: '_PUB',
3200: x_return_status);
3201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3202: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3204: raise OKC_API.G_EXCEPTION_ERROR;
3205: END IF;
3206: -- Call user hook for BEFORE

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

3199: '_PUB',
3200: x_return_status);
3201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3202: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3204: raise OKC_API.G_EXCEPTION_ERROR;
3205: END IF;
3206: -- Call user hook for BEFORE
3207: g_isev_ext_rec := l_isev_ext_rec;

Line 3204: raise OKC_API.G_EXCEPTION_ERROR;

3200: x_return_status);
3201: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3202: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3203: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3204: raise OKC_API.G_EXCEPTION_ERROR;
3205: END IF;
3206: -- Call user hook for BEFORE
3207: g_isev_ext_rec := l_isev_ext_rec;
3208: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

3205: END IF;
3206: -- Call user hook for BEFORE
3207: g_isev_ext_rec := l_isev_ext_rec;
3208: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3209: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3211: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3212: raise OKC_API.G_EXCEPTION_ERROR;
3213: END IF;

Line 3210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3206: -- Call user hook for BEFORE
3207: g_isev_ext_rec := l_isev_ext_rec;
3208: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3209: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3211: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3212: raise OKC_API.G_EXCEPTION_ERROR;
3213: END IF;
3214: l_isev_ext_rec := migrate_isev(l_isev_ext_rec, g_isev_ext_rec);

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

3207: g_isev_ext_rec := l_isev_ext_rec;
3208: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3209: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3211: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3212: raise OKC_API.G_EXCEPTION_ERROR;
3213: END IF;
3214: l_isev_ext_rec := migrate_isev(l_isev_ext_rec, g_isev_ext_rec);
3215: OKC_TIME_PVT.UPDATE_IA_STARTEND(

Line 3212: raise OKC_API.G_EXCEPTION_ERROR;

3208: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3209: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3211: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3212: raise OKC_API.G_EXCEPTION_ERROR;
3213: END IF;
3214: l_isev_ext_rec := migrate_isev(l_isev_ext_rec, g_isev_ext_rec);
3215: OKC_TIME_PVT.UPDATE_IA_STARTEND(
3216: p_api_version,

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

3219: x_msg_count,
3220: x_msg_data,
3221: p_isev_ext_rec,
3222: x_isev_ext_rec);
3223: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3224: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3225: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3226: raise OKC_API.G_EXCEPTION_ERROR;
3227: END IF;

Line 3224: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3220: x_msg_data,
3221: p_isev_ext_rec,
3222: x_isev_ext_rec);
3223: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3224: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3225: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3226: raise OKC_API.G_EXCEPTION_ERROR;
3227: END IF;
3228:

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

3221: p_isev_ext_rec,
3222: x_isev_ext_rec);
3223: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3224: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3225: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3226: raise OKC_API.G_EXCEPTION_ERROR;
3227: END IF;
3228:
3229: -- Call user hook for AFTER

Line 3226: raise OKC_API.G_EXCEPTION_ERROR;

3222: x_isev_ext_rec);
3223: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3224: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3225: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3226: raise OKC_API.G_EXCEPTION_ERROR;
3227: END IF;
3228:
3229: -- Call user hook for AFTER
3230: g_isev_ext_rec := x_isev_ext_rec;

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

3228:
3229: -- Call user hook for AFTER
3230: g_isev_ext_rec := x_isev_ext_rec;
3231: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3232: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3233: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3234: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3235: raise OKC_API.G_EXCEPTION_ERROR;
3236: END IF;

Line 3233: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3229: -- Call user hook for AFTER
3230: g_isev_ext_rec := x_isev_ext_rec;
3231: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3232: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3233: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3234: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3235: raise OKC_API.G_EXCEPTION_ERROR;
3236: END IF;
3237: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

3230: g_isev_ext_rec := x_isev_ext_rec;
3231: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3232: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3233: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3234: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3235: raise OKC_API.G_EXCEPTION_ERROR;
3236: END IF;
3237: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3238: EXCEPTION

Line 3235: raise OKC_API.G_EXCEPTION_ERROR;

3231: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3232: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3233: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3234: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3235: raise OKC_API.G_EXCEPTION_ERROR;
3236: END IF;
3237: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3238: EXCEPTION
3239: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

3233: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3234: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3235: raise OKC_API.G_EXCEPTION_ERROR;
3236: END IF;
3237: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3238: EXCEPTION
3239: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3240: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3241: (l_api_name,

Line 3239: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3235: raise OKC_API.G_EXCEPTION_ERROR;
3236: END IF;
3237: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3238: EXCEPTION
3239: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3240: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3241: (l_api_name,
3242: G_PKG_NAME,
3243: 'OKC_API.G_RET_STS_ERROR',

Line 3240: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3236: END IF;
3237: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3238: EXCEPTION
3239: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3240: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3241: (l_api_name,
3242: G_PKG_NAME,
3243: 'OKC_API.G_RET_STS_ERROR',
3244: x_msg_count,

Line 3243: 'OKC_API.G_RET_STS_ERROR',

3239: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3240: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3241: (l_api_name,
3242: G_PKG_NAME,
3243: 'OKC_API.G_RET_STS_ERROR',
3244: x_msg_count,
3245: x_msg_data,
3246: '_PUB');
3247: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 3247: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3243: 'OKC_API.G_RET_STS_ERROR',
3244: x_msg_count,
3245: x_msg_data,
3246: '_PUB');
3247: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3248: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3249: (l_api_name,
3250: G_PKG_NAME,
3251: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3248: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3244: x_msg_count,
3245: x_msg_data,
3246: '_PUB');
3247: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3248: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3249: (l_api_name,
3250: G_PKG_NAME,
3251: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3252: x_msg_count,

Line 3251: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3247: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3248: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3249: (l_api_name,
3250: G_PKG_NAME,
3251: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3252: x_msg_count,
3253: x_msg_data,
3254: '_PUB');
3255: WHEN OTHERS THEN

Line 3256: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3252: x_msg_count,
3253: x_msg_data,
3254: '_PUB');
3255: WHEN OTHERS THEN
3256: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3257: (l_api_name,
3258: G_PKG_NAME,
3259: 'OTHERS',
3260: x_msg_count,

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

3270: x_msg_data OUT NOCOPY VARCHAR2,
3271: p_isev_ext_tbl IN isev_ext_tbl_type,
3272: x_isev_ext_tbl OUT NOCOPY isev_ext_tbl_type) IS
3273: i NUMBER := 0;
3274: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3275: BEGIN
3276: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3277: IF p_isev_ext_tbl.COUNT > 0 THEN
3278: i := p_isev_ext_tbl.FIRST;

Line 3276: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3272: x_isev_ext_tbl OUT NOCOPY isev_ext_tbl_type) IS
3273: i NUMBER := 0;
3274: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3275: BEGIN
3276: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3277: IF p_isev_ext_tbl.COUNT > 0 THEN
3278: i := p_isev_ext_tbl.FIRST;
3279: LOOP
3280: UPDATE_IA_STARTEND(

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

3284: x_msg_count,
3285: x_msg_data,
3286: p_isev_ext_tbl(i),
3287: x_isev_ext_tbl(i));
3288: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3289: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3290: x_return_status := l_return_status;
3291: raise G_EXCEPTION_HALT_VALIDATION;
3292: ELSE

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

3285: x_msg_data,
3286: p_isev_ext_tbl(i),
3287: x_isev_ext_tbl(i));
3288: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3289: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3290: x_return_status := l_return_status;
3291: raise G_EXCEPTION_HALT_VALIDATION;
3292: ELSE
3293: x_return_status := l_return_status;

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

3300: EXCEPTION
3301: WHEN G_EXCEPTION_HALT_VALIDATION THEN
3302: NULL;
3303: WHEN OTHERS THEN
3304: OKC_API.set_message(p_app_name => g_app_name,
3305: p_msg_name => g_unexpected_error,
3306: p_token1 => g_sqlcode_token,
3307: p_token1_value => sqlcode,
3308: p_token2 => g_sqlerrm_token,

Line 3310: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

3306: p_token1 => g_sqlcode_token,
3307: p_token1_value => sqlcode,
3308: p_token2 => g_sqlerrm_token,
3309: p_token2_value => sqlerrm);
3310: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
3311: END UPDATE_IA_STARTEND;
3312:
3313: PROCEDURE DELETE_IA_STARTEND(
3314: p_api_version IN NUMBER,

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

3320: l_api_name CONSTANT VARCHAR2(30) := 'DELETE_IA_STARTEND';
3321: l_return_status VARCHAR2(1);
3322: l_isev_ext_rec isev_ext_rec_type := p_isev_ext_rec;
3323: BEGIN
3324: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3325: p_init_msg_list,
3326: '_PUB',
3327: x_return_status);
3328: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

3324: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
3325: p_init_msg_list,
3326: '_PUB',
3327: x_return_status);
3328: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3329: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3330: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3331: raise OKC_API.G_EXCEPTION_ERROR;
3332: END IF;

Line 3329: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3325: p_init_msg_list,
3326: '_PUB',
3327: x_return_status);
3328: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3329: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3330: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3331: raise OKC_API.G_EXCEPTION_ERROR;
3332: END IF;
3333: -- Call user hook for BEFORE

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

3326: '_PUB',
3327: x_return_status);
3328: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3329: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3330: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3331: raise OKC_API.G_EXCEPTION_ERROR;
3332: END IF;
3333: -- Call user hook for BEFORE
3334: g_isev_ext_rec := l_isev_ext_rec;

Line 3331: raise OKC_API.G_EXCEPTION_ERROR;

3327: x_return_status);
3328: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3329: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3330: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
3331: raise OKC_API.G_EXCEPTION_ERROR;
3332: END IF;
3333: -- Call user hook for BEFORE
3334: g_isev_ext_rec := l_isev_ext_rec;
3335: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

3332: END IF;
3333: -- Call user hook for BEFORE
3334: g_isev_ext_rec := l_isev_ext_rec;
3335: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3336: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3337: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3338: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3339: raise OKC_API.G_EXCEPTION_ERROR;
3340: END IF;

Line 3337: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3333: -- Call user hook for BEFORE
3334: g_isev_ext_rec := l_isev_ext_rec;
3335: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3336: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3337: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3338: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3339: raise OKC_API.G_EXCEPTION_ERROR;
3340: END IF;
3341: OKC_TIME_PVT.DELETE_IA_STARTEND(

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

3334: g_isev_ext_rec := l_isev_ext_rec;
3335: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3336: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3337: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3338: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3339: raise OKC_API.G_EXCEPTION_ERROR;
3340: END IF;
3341: OKC_TIME_PVT.DELETE_IA_STARTEND(
3342: p_api_version,

Line 3339: raise OKC_API.G_EXCEPTION_ERROR;

3335: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
3336: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3337: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3338: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3339: raise OKC_API.G_EXCEPTION_ERROR;
3340: END IF;
3341: OKC_TIME_PVT.DELETE_IA_STARTEND(
3342: p_api_version,
3343: p_init_msg_list,

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

3344: x_return_status,
3345: x_msg_count,
3346: x_msg_data,
3347: p_isev_ext_rec);
3348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3351: raise OKC_API.G_EXCEPTION_ERROR;
3352: END IF;

Line 3349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3345: x_msg_count,
3346: x_msg_data,
3347: p_isev_ext_rec);
3348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3351: raise OKC_API.G_EXCEPTION_ERROR;
3352: END IF;
3353:

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

3346: x_msg_data,
3347: p_isev_ext_rec);
3348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3351: raise OKC_API.G_EXCEPTION_ERROR;
3352: END IF;
3353:
3354: -- Call user hook for AFTER

Line 3351: raise OKC_API.G_EXCEPTION_ERROR;

3347: p_isev_ext_rec);
3348: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3349: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3350: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3351: raise OKC_API.G_EXCEPTION_ERROR;
3352: END IF;
3353:
3354: -- Call user hook for AFTER
3355: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');

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

3352: END IF;
3353:
3354: -- Call user hook for AFTER
3355: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3359: raise OKC_API.G_EXCEPTION_ERROR;
3360: END IF;

Line 3357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

3353:
3354: -- Call user hook for AFTER
3355: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3359: raise OKC_API.G_EXCEPTION_ERROR;
3360: END IF;
3361: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

3354: -- Call user hook for AFTER
3355: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3359: raise OKC_API.G_EXCEPTION_ERROR;
3360: END IF;
3361: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3362: EXCEPTION

Line 3359: raise OKC_API.G_EXCEPTION_ERROR;

3355: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
3356: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3359: raise OKC_API.G_EXCEPTION_ERROR;
3360: END IF;
3361: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3362: EXCEPTION
3363: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

3357: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
3358: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
3359: raise OKC_API.G_EXCEPTION_ERROR;
3360: END IF;
3361: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3362: EXCEPTION
3363: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3364: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3365: (l_api_name,

Line 3363: WHEN OKC_API.G_EXCEPTION_ERROR THEN

3359: raise OKC_API.G_EXCEPTION_ERROR;
3360: END IF;
3361: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3362: EXCEPTION
3363: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3364: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3365: (l_api_name,
3366: G_PKG_NAME,
3367: 'OKC_API.G_RET_STS_ERROR',

Line 3364: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3360: END IF;
3361: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
3362: EXCEPTION
3363: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3364: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3365: (l_api_name,
3366: G_PKG_NAME,
3367: 'OKC_API.G_RET_STS_ERROR',
3368: x_msg_count,

Line 3367: 'OKC_API.G_RET_STS_ERROR',

3363: WHEN OKC_API.G_EXCEPTION_ERROR THEN
3364: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3365: (l_api_name,
3366: G_PKG_NAME,
3367: 'OKC_API.G_RET_STS_ERROR',
3368: x_msg_count,
3369: x_msg_data,
3370: '_PUB');
3371: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 3371: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

3367: 'OKC_API.G_RET_STS_ERROR',
3368: x_msg_count,
3369: x_msg_data,
3370: '_PUB');
3371: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3373: (l_api_name,
3374: G_PKG_NAME,
3375: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 3372: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3368: x_msg_count,
3369: x_msg_data,
3370: '_PUB');
3371: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3373: (l_api_name,
3374: G_PKG_NAME,
3375: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3376: x_msg_count,

Line 3375: 'OKC_API.G_RET_STS_UNEXP_ERROR',

3371: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
3372: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3373: (l_api_name,
3374: G_PKG_NAME,
3375: 'OKC_API.G_RET_STS_UNEXP_ERROR',
3376: x_msg_count,
3377: x_msg_data,
3378: '_PUB');
3379: WHEN OTHERS THEN

Line 3380: x_return_status := OKC_API.HANDLE_EXCEPTIONS

3376: x_msg_count,
3377: x_msg_data,
3378: '_PUB');
3379: WHEN OTHERS THEN
3380: x_return_status := OKC_API.HANDLE_EXCEPTIONS
3381: (l_api_name,
3382: G_PKG_NAME,
3383: 'OTHERS',
3384: x_msg_count,

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

3393: x_msg_count OUT NOCOPY NUMBER,
3394: x_msg_data OUT NOCOPY VARCHAR2,
3395: p_isev_ext_tbl IN isev_ext_tbl_type) IS
3396: i NUMBER := 0;
3397: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3398: BEGIN
3399: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3400: IF p_isev_ext_tbl.COUNT > 0 THEN
3401: i := p_isev_ext_tbl.FIRST;

Line 3399: x_return_status := OKC_API.G_RET_STS_SUCCESS;

3395: p_isev_ext_tbl IN isev_ext_tbl_type) IS
3396: i NUMBER := 0;
3397: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
3398: BEGIN
3399: x_return_status := OKC_API.G_RET_STS_SUCCESS;
3400: IF p_isev_ext_tbl.COUNT > 0 THEN
3401: i := p_isev_ext_tbl.FIRST;
3402: LOOP
3403: DELETE_IA_STARTEND(

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

3406: l_return_status,
3407: x_msg_count,
3408: x_msg_data,
3409: p_isev_ext_tbl(i));
3410: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
3411: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
3412: x_return_status := l_return_status;
3413: raise G_EXCEPTION_HALT_VALIDATION;
3414: ELSE